perm filename LISP.RPG[S,DOC]10 blob
sn#654906 filedate 1982-04-16 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00236 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00037 00002 **DRAFT** The Language **DRAFT**
C00039 00003 **DRAFT** General Information **DRAFT**
C00044 00004 **DRAFT** Maclisp Reference Manual **DRAFT**
C00047 00005 **DRAFT** General Information **DRAFT**
C00051 00006 **DRAFT** Maclisp Reference Manual **DRAFT**
C00055 00007 **DRAFT** General Information **DRAFT**
C00058 00008 **DRAFT** Maclisp Reference Manual **DRAFT**
C00059 00009 **DRAFT** Data Objects **DRAFT**
C00064 00010 **DRAFT** Maclisp Reference Manual **DRAFT**
C00069 00011 **DRAFT** Data Objects **DRAFT**
C00074 00012 **DRAFT** Maclisp Reference Manual **DRAFT**
C00078 00013 **DRAFT** Data Objects **DRAFT**
C00080 00014 **DRAFT** Maclisp Reference Manual **DRAFT**
C00081 00015 **DRAFT** The Basic Actions of LISP **DRAFT**
C00086 00016 **DRAFT** Maclisp Reference Manual **DRAFT**
C00090 00017 **DRAFT** The Basic Actions of LISP **DRAFT**
C00095 00018 **DRAFT** Maclisp Reference Manual **DRAFT**
C00098 00019 **DRAFT** The Basic Actions of LISP **DRAFT**
C00102 00020 **DRAFT** Maclisp Reference Manual **DRAFT**
C00106 00021 **DRAFT** The Basic Actions of LISP **DRAFT**
C00110 00022 **DRAFT** Maclisp Reference Manual **DRAFT**
C00113 00023 **DRAFT** The Basic Actions of LISP **DRAFT**
C00117 00024 **DRAFT** Maclisp Reference Manual **DRAFT**
C00120 00025 **DRAFT** The Basic Actions of LISP **DRAFT**
C00122 00026 **DRAFT** Maclisp Reference Manual **DRAFT**
C00125 00027 **DRAFT** Function Descriptions **DRAFT**
C00130 00028 **DRAFT** Maclisp Reference Manual **DRAFT**
C00131 00029 **DRAFT** Predicates **DRAFT**
C00134 00030 **DRAFT** Maclisp Reference Manual **DRAFT**
C00137 00031 **DRAFT** Predicates **DRAFT**
C00141 00032 **DRAFT** Maclisp Reference Manual **DRAFT**
C00144 00033 **DRAFT** Predicates **DRAFT**
C00145 00034 **DRAFT** Maclisp Reference Manual **DRAFT**
C00146 00035 **DRAFT** The Evaluator **DRAFT**
C00149 00036 **DRAFT** Maclisp Reference Manual **DRAFT**
C00153 00037 **DRAFT** The Evaluator **DRAFT**
C00157 00038 **DRAFT** Maclisp Reference Manual **DRAFT**
C00160 00039 **DRAFT** The Evaluator **DRAFT**
C00164 00040 **DRAFT** Maclisp Reference Manual **DRAFT**
C00167 00041 **DRAFT** The Evaluator **DRAFT**
C00170 00042 **DRAFT** Maclisp Reference Manual **DRAFT**
C00172 00043 **DRAFT** Manipulating List Structure **DRAFT**
C00175 00044 **DRAFT** Maclisp Reference Manual **DRAFT**
C00178 00045 **DRAFT** Manipulating List Structure **DRAFT**
C00180 00046 **DRAFT** Maclisp Reference Manual **DRAFT**
C00183 00047 **DRAFT** Manipulating List Structure **DRAFT**
C00186 00048 **DRAFT** Maclisp Reference Manual **DRAFT**
C00189 00049 **DRAFT** Manipulating List Structure **DRAFT**
C00192 00050 **DRAFT** Maclisp Reference Manual **DRAFT**
C00193 00051 **DRAFT** Manipulating List Structure **DRAFT**
C00196 00052 **DRAFT** Maclisp Reference Manual **DRAFT**
C00200 00053 **DRAFT** Manipulating List Structure **DRAFT**
C00204 00054 **DRAFT** Maclisp Reference Manual **DRAFT**
C00207 00055 **DRAFT** Manipulating List Structure **DRAFT**
C00210 00056 **DRAFT** Maclisp Reference Manual **DRAFT**
C00213 00057 **DRAFT** Manipulating List Structure **DRAFT**
C00216 00058 **DRAFT** Maclisp Reference Manual **DRAFT**
C00219 00059 **DRAFT** Manipulating List Structure **DRAFT**
C00223 00060 **DRAFT** Maclisp Reference Manual **DRAFT**
C00225 00061 **DRAFT** Manipulating List Structure **DRAFT**
C00229 00062 **DRAFT** Maclisp Reference Manual **DRAFT**
C00232 00063 **DRAFT** Flow of Control **DRAFT**
C00236 00064 **DRAFT** Maclisp Reference Manual **DRAFT**
C00239 00065 **DRAFT** Flow of Control **DRAFT**
C00243 00066 **DRAFT** Maclisp Reference Manual **DRAFT**
C00247 00067 **DRAFT** Flow of Control **DRAFT**
C00251 00068 **DRAFT** Maclisp Reference Manual **DRAFT**
C00256 00069 **DRAFT** Flow of Control **DRAFT**
C00259 00070 **DRAFT** Maclisp Reference Manual **DRAFT**
C00262 00071 **DRAFT** Flow of Control **DRAFT**
C00265 00072 **DRAFT** Maclisp Reference Manual **DRAFT**
C00268 00073 **DRAFT** Flow of Control **DRAFT**
C00270 00074 **DRAFT** Maclisp Reference Manual **DRAFT**
C00274 00075 **DRAFT** Flow of Control **DRAFT**
C00277 00076 **DRAFT** Maclisp Reference Manual **DRAFT**
C00278 00077 **DRAFT** Atomic Symbols **DRAFT**
C00282 00078 **DRAFT** Maclisp Reference Manual **DRAFT**
C00285 00079 **DRAFT** Atomic Symbols **DRAFT**
C00287 00080 **DRAFT** Maclisp Reference Manual **DRAFT**
C00291 00081 **DRAFT** Atomic Symbols **DRAFT**
C00303 00082 **DRAFT** Maclisp Reference Manual **DRAFT**
C00306 00083 **DRAFT** Atomic Symbols **DRAFT**
C00309 00084 **DRAFT** Maclisp Reference Manual **DRAFT**
C00312 00085 **DRAFT** Atomic Symbols **DRAFT**
C00314 00086 **DRAFT** Maclisp Reference Manual **DRAFT**
C00318 00087 **DRAFT** Atomic Symbols **DRAFT**
C00322 00088 **DRAFT** Maclisp Reference Manual **DRAFT**
C00323 00089 **DRAFT** Atomic Symbols **DRAFT**
C00326 00090 **DRAFT** Maclisp Reference Manual **DRAFT**
C00330 00091 **DRAFT** Atomic Symbols **DRAFT**
C00333 00092 **DRAFT** Maclisp Reference Manual **DRAFT**
C00334 00093 **DRAFT** Numbers **DRAFT**
C00336 00094 **DRAFT** Maclisp Reference Manual **DRAFT**
C00338 00095 **DRAFT** Numbers **DRAFT**
C00341 00096 **DRAFT** Maclisp Reference Manual **DRAFT**
C00343 00097 **DRAFT** Numbers **DRAFT**
C00345 00098 **DRAFT** Maclisp Reference Manual **DRAFT**
C00347 00099 **DRAFT** Numbers **DRAFT**
C00350 00100 **DRAFT** Maclisp Reference Manual **DRAFT**
C00353 00101 **DRAFT** Numbers **DRAFT**
C00354 00102 **DRAFT** Maclisp Reference Manual **DRAFT**
C00357 00103 **DRAFT** Numbers **DRAFT**
C00360 00104 **DRAFT** Maclisp Reference Manual **DRAFT**
C00361 00105 **DRAFT** Numbers **DRAFT**
C00364 00106 **DRAFT** Maclisp Reference Manual **DRAFT**
C00366 00107 **DRAFT** Numbers **DRAFT**
C00368 00108 **DRAFT** Maclisp Reference Manual **DRAFT**
C00370 00109 **DRAFT** Numbers **DRAFT**
C00373 00110 **DRAFT** Maclisp Reference Manual **DRAFT**
C00376 00111 **DRAFT** Numbers **DRAFT**
C00379 00112 **DRAFT** Maclisp Reference Manual **DRAFT**
C00381 00113 **DRAFT** Character Manipulation **DRAFT**
C00384 00114 **DRAFT** Maclisp Reference Manual **DRAFT**
C00388 00115 **DRAFT** Character Manipulation **DRAFT**
C00391 00116 **DRAFT** Maclisp Reference Manual **DRAFT**
C00392 00117 **DRAFT** Character Manipulation **DRAFT**
C00395 00118 **DRAFT** Maclisp Reference Manual **DRAFT**
C00397 00119 **DRAFT** Arrays **DRAFT**
C00402 00120 **DRAFT** Maclisp Reference Manual **DRAFT**
C00407 00121 **DRAFT** Arrays **DRAFT**
C00412 00122 **DRAFT** Maclisp Reference Manual **DRAFT**
C00415 00123 **DRAFT** Arrays **DRAFT**
C00419 00124 **DRAFT** Maclisp Reference Manual **DRAFT**
C00423 00125 **DRAFT** Arrays **DRAFT**
C00427 00126 **DRAFT** Maclisp Reference Manual **DRAFT**
C00428 00127 **DRAFT** Mapping Functions **DRAFT**
C00432 00128 **DRAFT** Maclisp Reference Manual **DRAFT**
C00435 00129 **DRAFT** Mapping Functions **DRAFT**
C00439 00130 **DRAFT** Maclisp Reference Manual **DRAFT**
C00440 00131 **DRAFT** The System **DRAFT**
C00445 00132 **DRAFT** The System **DRAFT**
C00446 00133 **DRAFT** Maclisp Reference Manual **DRAFT**
C00450 00134 **DRAFT** The System **DRAFT**
C00454 00135 **DRAFT** Maclisp Reference Manual **DRAFT**
C00456 00136 **DRAFT** The System **DRAFT**
C00461 00137 **DRAFT** Maclisp Reference Manual **DRAFT**
C00463 00138 **DRAFT** The System **DRAFT**
C00466 00139 **DRAFT** Maclisp Reference Manual **DRAFT**
C00470 00140 **DRAFT** The System **DRAFT**
C00475 00141 **DRAFT** Maclisp Reference Manual **DRAFT**
C00479 00142 **DRAFT** The System **DRAFT**
C00484 00143 **DRAFT** Maclisp Reference Manual **DRAFT**
C00488 00144 **DRAFT** The System **DRAFT**
C00491 00145 **DRAFT** Maclisp Reference Manual **DRAFT**
C00493 00146 **DRAFT** The System **DRAFT**
C00498 00147 **DRAFT** Maclisp Reference Manual **DRAFT**
C00503 00148 **DRAFT** The System **DRAFT**
C00508 00149 **DRAFT** Maclisp Reference Manual **DRAFT**
C00512 00150 **DRAFT** The System **DRAFT**
C00516 00151 **DRAFT** Maclisp Reference Manual **DRAFT**
C00521 00152 **DRAFT** The System **DRAFT**
C00525 00153 **DRAFT** Maclisp Reference Manual **DRAFT**
C00529 00154 **DRAFT** The System **DRAFT**
C00533 00155 **DRAFT** Maclisp Reference Manual **DRAFT**
C00537 00156 **DRAFT** The System **DRAFT**
C00541 00157 **DRAFT** Maclisp Reference Manual **DRAFT**
C00546 00158 **DRAFT** The System **DRAFT**
C00548 00159 **DRAFT** Maclisp Reference Manual **DRAFT**
C00552 00160 **DRAFT** The System **DRAFT**
C00556 00161 **DRAFT** Maclisp Reference Manual **DRAFT**
C00560 00162 **DRAFT** The System **DRAFT**
C00564 00163 **DRAFT** Maclisp Reference Manual **DRAFT**
C00569 00164 **DRAFT** The System **DRAFT**
C00573 00165 **DRAFT** Maclisp Reference Manual **DRAFT**
C00575 00166 **DRAFT** The System **DRAFT**
C00579 00167 **DRAFT** Maclisp Reference Manual **DRAFT**
C00584 00168 **DRAFT** The System **DRAFT**
C00587 00169 **DRAFT** Maclisp Reference Manual **DRAFT**
C00591 00170 **DRAFT** The System **DRAFT**
C00593 00171 **DRAFT** Maclisp Reference Manual **DRAFT**
C00596 00172 **DRAFT** The System **DRAFT**
C00600 00173 **DRAFT** Maclisp Reference Manual **DRAFT**
C00604 00174 **DRAFT** The System **DRAFT**
C00608 00175 **DRAFT** Maclisp Reference Manual **DRAFT**
C00613 00176 **DRAFT** The System **DRAFT**
C00618 00177 **DRAFT** Maclisp Reference Manual **DRAFT**
C00622 00178 **DRAFT** The System **DRAFT**
C00626 00179 **DRAFT** Maclisp Reference Manual **DRAFT**
C00631 00180 **DRAFT** The System **DRAFT**
C00636 00181 **DRAFT** Maclisp Reference Manual **DRAFT**
C00641 00182 **DRAFT** The System **DRAFT**
C00645 00183 **DRAFT** Maclisp Reference Manual **DRAFT**
C00650 00184 **DRAFT** The System **DRAFT**
C00655 00185 **DRAFT** Maclisp Reference Manual **DRAFT**
C00659 00186 **DRAFT** The System **DRAFT**
C00664 00187 **DRAFT** Maclisp Reference Manual **DRAFT**
C00668 00188 **DRAFT** The System **DRAFT**
C00670 00189 **DRAFT** Maclisp Reference Manual **DRAFT**
C00674 00190 **DRAFT** The System **DRAFT**
C00676 00191 **DRAFT** Maclisp Reference Manual **DRAFT**
C00680 00192 **DRAFT** The System **DRAFT**
C00684 00193 **DRAFT** Maclisp Reference Manual **DRAFT**
C00687 00194 **DRAFT** The System **DRAFT**
C00692 00195 **DRAFT** Maclisp Reference Manual **DRAFT**
C00697 00196 **DRAFT** The System **DRAFT**
C00701 00197 **DRAFT** Maclisp Reference Manual **DRAFT**
C00706 00198 **DRAFT** The System **DRAFT**
C00711 00199 **DRAFT** Maclisp Reference Manual **DRAFT**
C00712 00200 **DRAFT** The System **DRAFT**
C00716 00201 **DRAFT** Maclisp Reference Manual **DRAFT**
C00721 00202 **DRAFT** The System **DRAFT**
C00725 00203 **DRAFT** Maclisp Reference Manual **DRAFT**
C00728 00204 **DRAFT** The System **DRAFT**
C00732 00205 **DRAFT** Maclisp Reference Manual **DRAFT**
C00736 00206 **DRAFT** The System **DRAFT**
C00740 00207 **DRAFT** Maclisp Reference Manual **DRAFT**
C00745 00208 **DRAFT** The System **DRAFT**
C00750 00209 **DRAFT** Maclisp Reference Manual **DRAFT**
C00754 00210 **DRAFT** The System **DRAFT**
C00758 00211 **DRAFT** Maclisp Reference Manual **DRAFT**
C00764 00212 **DRAFT** The System **DRAFT**
C00769 00213 **DRAFT** Maclisp Reference Manual **DRAFT**
C00773 00214 **DRAFT** The System **DRAFT**
C00778 00215 **DRAFT** Maclisp Reference Manual **DRAFT**
C00782 00216 **DRAFT** The System **DRAFT**
C00787 00217 **DRAFT** Maclisp Reference Manual **DRAFT**
C00791 00218 **DRAFT** The System **DRAFT**
C00795 00219 **DRAFT** Maclisp Reference Manual **DRAFT**
C00799 00220 **DRAFT** The System **DRAFT**
C00803 00221 **DRAFT** Maclisp Reference Manual **DRAFT**
C00807 00222 **DRAFT** The System **DRAFT**
C00812 00223 **DRAFT** Maclisp Reference Manual **DRAFT**
C00817 00224 **DRAFT** The System **DRAFT**
C00821 00225 **DRAFT** Maclisp Reference Manual **DRAFT**
C00824 00226 **DRAFT** The System **DRAFT**
C00828 00227 **DRAFT** Maclisp Reference Manual **DRAFT**
C00832 00228 **DRAFT** The System **DRAFT**
C00836 00229 **DRAFT** Maclisp Reference Manual **DRAFT**
C00840 00230 **DRAFT** The System **DRAFT**
C00843 00231 **DRAFT** Maclisp Reference Manual **DRAFT**
C00846 00232 **DRAFT** The System **DRAFT**
C00849 00233 **DRAFT** Maclisp Reference Manual **DRAFT**
C00852 00234 **DRAFT** The System **DRAFT**
C00856 00235 **DRAFT** Maclisp Reference Manual **DRAFT**
C00858 00236 **DRAFT** Function Index **DRAFT**
C00867 ENDMK
C⊗;
**DRAFT** The Language **DRAFT**
Part 1 - The Language
Table of Contents
1. General Information . . . . . . . . . . . . . . . . . . . . . . . . 1-1
1.1 The Maclisp Language . . . . . . . . . . . . . . . . . . . . . . . . 1-1
1.2 Structure of the Manual . . . . . . . . . . . . . . . . . . . . . . 1-3
1.3 Notational Conventions . . . . . . . . . . . . . . . . . . . . . . . 1-4
2. Data Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-7
3. The Basic Actions of LISP . . . . . . . . . . . . . . . . . . . . .1-13
3.1 Binding of Variables . . . . . . . . . . . . . . . . . . . . . . . .1-13
3.2 Evaluation of Forms . . . . . . . . . . . . . . . . . . . . . . . .1-15
3.3 Application of Functions . . . . . . . . . . . . . . . . . . . . . .1-17
3.4 Special Forms . . . . . . . . . . . . . . . . . . . . . . . . . . .1-21
3.5 Binding Context Pointers . . . . . . . . . . . . . . . . . . . . . .1-24
December 5, 1977 Page 1-1
**DRAFT** General Information **DRAFT**
1. General Information
1.1 The Maclisp Language
Maclisp is a dialect of Lisp developed at M.I.T.'s Project MAC and M.I.T.'s
Artificial Intelligence Laboratory for use in artificial intelligence research
and related fields. Maclisp is descended from the commonly-known Lisp 1.5
dialect; however, many features of the language have been changed or augmented.
This document is intended both as a reference source for the language and as
a user's guide to three implementations. These are, in chronological order, the
M.I.T. Artificial Intelligence Lab's implementation on the DEC pdp-10 computer
under their operating system ITS, hereafter referred to as "the ITS
implementation," Project MAC's implementation on Honeywell's version of the
Multics system, hereafter referred to as "the Multics implementation," and the
version that runs on the DEC pdp-10 under DEC's TOPS-10 operating system,
hereafter called "the DEC-10 implementation." The DEC-10 implementation also
runs under TENEX by means of a TOPS-10 emulator. Since the ITS and DEC-10
implementations are closely related, they are sometimes referred to collectively
as the pdp-10 implementation. There are reputed to be several other
implementations.
These implementations are mostly compatible; however, some implementations
have extra features designed to exploit peculiar features of the system on which
they run, and some implementations are temporarily missing some features. Most
programs will work on any implementation, although it is possible to write
machine-dependent code if you try hard enough.
The Maclisp system is structured as an environment, which is essentially a
set of names and bindings of those names to data structures and function
definitions. The environment contains a large number of useful functions.
These functions can be used through an interpreter to define other functions, to
control the environment, to do useful work, etc.
The interpreter is the basic user interface to the system. This is how the
user enters "commands." When Maclisp is not doing anything else, such as running
a program, it waits for the user to enter a Lisp form. This form is evaluated
and the value is printed out. The form may call upon one of the system
December 5, 1977 ∪1-1. Page 1-1
**DRAFT** Maclisp Reference Manual **DRAFT**
functions (or a user-defined function, of course) to perform some useful task.
The evaluation of a form may initiate the execution of a large and complex
program, perhaps never returning to the "top level" interpreter, or it may
perform some simple action and immediately wait for the user to type another
form.
It is also possible to get into the interpreter while a program is running,
using the break facility. This is primarily used in debugging and related
programming activities.
The functions invoked by the top-level interpreter may be executable machine
programs, or they may themselves be interpreted. This is entirely a matter of
choice and convenience. The system functions are mostly machine programs. User
functions are usually first used interpretively. After they work, the compiler
may be applied to them, turning them into machine programs which can then be
loaded into the environment.
All of this is done within a single consistent language, Lisp, whose virtue
is that the data structure is simple and general enough that programs may easily
operate on programs, and that the program structure is simple and general enough
that it can be used as a command language.
Page 1-2 ∪1-1.1 December 5, 1977
**DRAFT** General Information **DRAFT**
1.2 Structure of the Manual
The manual is generally structured into sections on particular topics; each
section contains explanatory text and function definitions, interspersed. In
general, each section contains both elementary and complex material, with
complexity increasing toward the end of the section. An axiomatic, step-by-step
development is not used. Frequently the more complex information in a section
will assume knowledge from other sections which appear later in the manual. The
new user is advised to skip around, reading early chapters and early sections of
chapters first.
Often descriptions of Lisp functions will be given not only in prose but also
in terms of other Lisp functions. These are as accurate as possible, but should
not be taken too literally. Their main purpose is to serve as a source of
examples.
Accessing information in the manual is dependent on both the user's level of
ability and the purpose for which she or he is using the manual. Though cover
to cover reading is not recommended (though not excluded), it is suggested that
someone who has never previously seen this manual browse through it, touching
the beginning of each subdivision that is listed in the Table of Contents, in
order to familiarize himself or herself with the material that it contains. To
find an answer to some particular question, one must use one of the provided
access methods. Since the manual is structured by topics one can use the Table
of Contents that is found at the beginning of the manual, and the more detailed
tables of contents found at the beginning of each of the six major parts, to
find where information of a general class will be found. Entry into the manual
is also facilitated by the Glossary and the Concept Index, which are found at
the end. Also at the end of the manual are a Function Index and an Atomic
Symbol Index which are probably most useful to a regular and repeated user of
the dialect, or to an experienced user of another dialect, who wishes to find
out the answer to a question about a specific function. When one section of the
manual assumes knowledge of another section a page number reference to the other
section will generally be given.
December 5, 1977 ∪1-1.2 Page 1-3
**DRAFT** Maclisp Reference Manual **DRAFT**
1.3 Notational Conventions
There are some conventions of notation that must be mentioned at this time,
due to their being used in examples.
Most numbers are in octal radix (base eight). Numbers with a decimal point
and spelled-out numbers are in decimal radix. It is important to remember that
by default Maclisp inputs and outputs all numbers in octal radix. If you want
to change this, see the variables base and ibase.
A combination of the characters equal sign and greater than symbol, "=>",
will be used in examples of Lisp code to mean evaluation. For instance, "F =>
V" means that evaluating the form F produces the value V.
All uses of the phrase "Lisp reader," unless further qualified, refer to that
part of the Lisp system which reads input, and not to the person reading this
document.
The terms "S-expression" and "Lisp object" are synonyms for "any piece of
Lisp data."
The character "$" always stands for dollar-sign, never for "alt mode," unless
that is specifically stated.
The two characters accent acute, "'", and semi-colon, ";", are examples of
what are called macro characters. Though the macro character facility, which is
explained in Part 5, is not of immediate interest to a new user of the dialect,
these two macro characters come preset by the Lisp system and are useful. When
the Lisp reader encounters an accent acute, or quote mark, it reads in the next
S-expression and encloses it in a quote-form, which prevents evaluation of the
S-expression. That is:
'some-atom
turns into:
(quote some-atom)
and
'(cons 'a 'b)
Page 1-4 ∪1-1.3 December 5, 1977
**DRAFT** General Information **DRAFT**
turns into
(quote (cons (quote a) (quote b)))
The semi-colon (;) is used as a commenting character. When the Lisp reader
encounters it, the remainder of the line is discarded.
The term "newline" is used to refer to that character or sequence of
characters which indicates the end of a line. This is implementation dependent.
In Multics Maclisp, newline is the Multics newline character, octal 012. In ITS
Maclisp, newline is carriage return (octal 015), optionally followed by line
feed (octal 012.) In dec-10 Maclisp, newline is carriage return followed by
line feed.
All Lisp examples in this manual are written according to the case
conventions of the Multics implementation, which uses both upper and lower case
letters and spells the names of most system functions in lower case. Some
implementations of Maclisp use only upper case letters because they exist on
systems which are not, or have not always been, equipped with terminals capable
of generating and displaying the full ascii character set. However, these
implementations will accept input in lower case and translate it to upper case,
unless the user has explicitly said not to.
December 5, 1977 ∪1-1.3 Page 1-5
**DRAFT** Maclisp Reference Manual **DRAFT**
Page 1-6 ∪1-1.3 December 5, 1977
**DRAFT** Data Objects **DRAFT**
2. Data Objects
Lisp works with pieces of data called "objects" or "S-expressions." These can
be simple "atomic" objects or complex objects compounded out of other objects.
Functions, the basic units of a Lisp program, are also objects and may be
manipulated as data.
Objects come in several types. All types are manifest; that is, it is
possible for a program to tell what type an object is just by looking at the
object itself, so it is not necessary to declare the types of variables as in
some other languages. One can make declarations, however, in order to aid the
compiler in producing optimal code. (See part 4.2.)
It is important to know that Lisp represents objects as pointers, so that a
storage cell (a "variable") will hold any object, and the same object may be
held by several different storage cells. For example, the same identical object
may be a component of two different compound objects.
The data-types are divided into three broad classes: the atomic types, the
non-atomic types, and the composite types. Objects are divided into the same
three classes according to their type. Atomic objects are basic units which
cannot be broken down by ordinary chemical means (car and cdr), while non-atomic
objects are structures constructed out of other objects. Composite objects are
indivisible, atomic, entities which have other objects associated with them.
These other objects may be examined and replaced.
The atomic data types are numbers, atomic symbols, strings, and subr-objects.
Atomic symbols can also be regarded as composite. See below.
In Lisp numbers can be represented by three types of atomic objects: fixnums,
flonums, and bignums. A fixnum is a fixed-point binary integer whose range of
values is machine-dependent. A flonum is a floating-point number whose
precision and range of values are machine-dependent. A bignum is an infinite-
precision integer. It is impossible to get "overflow" in bignum arithmetic, as
any integer can be represented by a bignum. However, fixnum and flonum
arithmetic is faster than bignum arithmetic and requires less memory. Sometimes
the word "fixnum" is used to include both fixnums and bignums (i.e. all
integers); in this manual, however, the word "fixnum" will never be used to
include bignums unless that is explicitly stated.
December 5, 1977 ∪1-2. Page 1-7
**DRAFT** Maclisp Reference Manual **DRAFT**
The printed representations for numbers are as follows: a fixnum is
represented as a sequence of digits in a specified base, usually octal. A
trailing decimal point indicates a decimal base. A flonum is represented as a
set of digits containing an embedded or leading decimal point and/or a trailing
exponent. The exponent is introduced by an upper or lower case "e". A bignum
looks like a fixnum except that it has enough digits that it will not fit within
the range available to fixnums. Any number may be preceded by a + or - sign.
Some examples of fixnums are 4, -1232, -191., +46. An example of a bignum is
1565656565656565656565656565656565. Some examples of flonums are: 4.0, .01,
-6e5, 4.2e-1.
One of the most important Lisp data types is the atomic symbol. In fact, the
word "atom" is often used to mean just atomic symbols, and not the other atomic
types. An atomic symbol has associated with it a name, a value, and possibly a
list of "properties". The name is a sequence of characters, which is the
printed representation of the atomic symbol. This name is often called the
"pname," or "print-name." A pname may contain any ascii character except the
full character, which causes trouble in some implementations. For example, a
certain atomic symbol would be represented externally as foo; internally as a
structure containing the value, the pname "foo", and the properties.
There are two special atomic symbols, t and nil. These always have their
respective selves as values and their values may not be changed. nil is used as
a "marker" in many contexts; it is essential to the construction of data
structures such as lists. t is usually used when an antithesis to nil is
required for some purpose, e.g. to represent the logical conditions "true" and
"false." Another property of the special atomic symbol nil is that its car and
its cdr are always nil.
The value of an atomic symbol can be any object of any type. There are
functions to set and get the value of a symbol. Because atomic symbols have
values associated with them, they can be used as variables in programs and as
"dummy arguments" in functions. It is also possible for an atomic symbol to
have no value, in which case it is said to be "undefined" or "unbound."
The property list of an atomic symbol is explained on page 2-52. It is used
for such things as recording the fact that an atomic symbol is the name of a
function.
An atomic symbol with one or no characters in its pname is often called a
"character object" and used to represent an ascii character. The atomic symbol
with a zero-length pname represents the ascii null character, and the symbols
Page 1-8 ∪1-2. December 5, 1977
**DRAFT** Data Objects **DRAFT**
with one-character pnames represent the character which is their pname.
Functions which take character objects as input usually also accept a string one
character long or a fixnum equal to the ascii-code value for the character.
Character objects are always interned on the obarray (see page 2-58).
Another Lisp data type is the string. This is a sequence of characters
(possibly zero-length). Strings are used to hold messages to be typed out and
to manipulate text when the structure of the text is not appropriate for the use
of "list processing." The printed representation of a string is a sequence of
characters enclosed in double-quotes, e.g. "foo". If a " is to be included in
the string, it is written twice, e.g. "foo""bar" is foo"bar. In implementations
without strings, atomic symbols are used instead. The pdp-10 implementations
currently lack strings.
A "subr-object" is a special atomic data-type whose use is normally hidden in
the implementation. A subr-object represents executable machine code. The
functions built into the Lisp system are subr-objects, as are user functions
that have been compiled. A subr-object has no printed representation, so each
system function has an atomic symbol which serves as its name. The symbol has
the subr-object as a property.
One composite data type is the array. An array consists of a number of
cells, each of which may contain any Lisp object. The cells of an array are
accessed by subscripting; each cell is named by a tuple of integers. An array
may have one or more dimensions; the upper limit on the number of dimensions is
implementation-defined. An array is not always associated with an atomic symbol
which is its name. Rather, an array is always designated by an array-pointer,
which is a special kind of atomic Lisp object. Frequently, an array-pointer
will be placed on the property list of a symbol under the indicator array and
then that symbol will be used as the name of the array, since symbols can have
printed representation. See page 2-89 for an
explanation of how to create, use, and delete arrays.
Another composite data type is the file-object, which is described on part
5.3.
The sole non-atomic data type is the "cons." A cons is a structure
containing two components, called the "car" and the "cdr" for historical
reasons. (These are names of fields in an IBM 7094 machine word.) These two
components may be any Lisp object, even another cons (in fact, they could even
be the same cons). In this way complex structures can be built up out of simple
conses. Internally a cons is represented in a form similar to:
December 5, 1977 ∪1-2. Page 1-9
**DRAFT** Maclisp Reference Manual **DRAFT**
←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←←
| | |
| car | cdr |
←λ|←←←←←←←←←←←←←←←←←←λ|←←←←←←←←←←←←←←←←←←λ|
where the boxes represent cells of memory large enough to hold a pointer, and
"car" and "cdr" are two pointers to objects. The printed representation of a
cons is the "dotted-pair" notation (A . B) where A is the car and B is the cdr.
Another way to write the internal representation of a cons, which is more
convenient for large structures, is:
---λ> o -----> cdr
|
|
V
car
There are three Lisp functions associated with conses: cons, car, and cdr.
The function cons combines its two arguments into a cons; (1 . 2) can be
generated by evaluating (cons 1 2). The function car returns the car component
of its argument, and the function cdr returns the cdr component of its argument.
One type of structure, built out of conses, that is used quite often, is the
"list." A list is a row of objects, of arbitrary length. A list of three
things 1, 2, and 3 is constructed by (cons 1 (cons 2 (cons 3 nil))); nil is a
special atom that is used to mark the end of a list. The structure of a list
can be diagrammed as:
---λ> o ----> o ----> o ----> nil
| | |
| | |
V V V
1 2 3
From this it can be seen that the car of a list is its first element, that
the cdr of a list is a list of the elements after the first, and that the list
of no elements is the same as nil.
This list of 1, 2, and 3 could be represented in the dot-notation used for
conses as (1 . (2 . (3 . nil))). However, a more convenient notation for the
Page 1-10 ∪1-2. December 5, 1977
**DRAFT** Data Objects **DRAFT**
printed representation of lists has been defined: the "list-notation" (1 2 3).
It is also possible to have a hybrid of the two notations which is used for
structures which are almost a list except that they end in an atom other than
nil. For example, (A . (B . (C . D))) can be represented as (A B C . D).
A list not containing any elements is perfectly legal and frequently used.
This zero-length list is identified with the atom nil. It may be typed in as
either nil or ().
December 5, 1977 ∪1-2. Page 1-11
**DRAFT** Maclisp Reference Manual **DRAFT**
Page 1-12 ∪1-2. December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
3. The Basic Actions of LISP
3.1 Binding of Variables
The basic primitives of programming in Lisp are variables, forms, and
functions. A variable is an atomic symbol which has a value associated with it;
the symbol is said to be bound to that value. The value may of course be any
Lisp object whatsoever. The atomic symbol acts simply as a name by which the
program may refer to the value while it is processing it.
This is similar to the concept of variables in other programming languages.
However, Lisp's concept of the scope of names is subtly different from that of
most "block-structured" languages. At a given moment, a variable may actually
have several bindings in existence. Only the most recent, or current binding,
can be used. When a new binding is created, the previous one is pushed onto a
stack. It will become accessible again when the binding which superseded it is
removed. Creation and removal of bindings is synchronized with subroutine
calling (and with certain special forms described below) so this mechanism
corresponds closely to the "local variables" concept of other programming
languages. However, Lisp considers that there is only one variable whose
binding changes, rather than several separate variables which happen to have the
same name. Any reference to a variable, even from outside the particular
program which gave it its current binding, gets the current binding and not one
determined by "scope rules." It is possible to simulate the other concept of
scope of names by using binding context pointers, which are described later (see
page 1-22).
Unlike many other languages, Lisp does not combine the concepts of name and
storage. Many languages associate with a variable (a name) a piece of storage
which can hold one object of a particular type, such as a floating point number.
The variable's value resides in this storage. It is then impossible for two
variables to really have "the same" value; one could have a copy of the value of
another but not the same identical object.
The situation in Lisp is quite different. Binding a variable to a value is
not copying the value into storage associated with that variable. Values exist
as separate objects in their own right and in their own storage. Binding is
simply an association between a variable and a value; consequently there is no
December 5, 1977 ∪1-3. Page 1-13
**DRAFT** Maclisp Reference Manual **DRAFT**
reason why two variables cannot have truly identical values. Similarly, erasing
the binding between a variable and its value does not destroy or throw away the
value; it simply breaks the association. Of course, if there is no other use
for the value the storage it occupies will eventually be reclaimed by the system
and put to more productive use.
Often these processes of creating a new binding of a variable to a value and
reverting to a previous binding are referred to as binding and unbinding the
variable, respectively.
A slightly different way of creating a binding between a variable and a value
is assignment. When a variable is bound to a value, the previous binding is
saved and can be restored, but when a variable has a value assigned to it, the
previous binding is not saved, but is simply replaced. Thus binding may be
regarded as creating a new level of usage of a variable, while assignment
switches a variable to a different value within the same level. For instance, a
subroutine or function may bind a variable to an initial value when it is
entered, and then proceed to make use of that variable, possibly assigning a
different value to it from time to time. The initial binding of the variable
establishes the (temporary) ownership of that variable by the subroutine.
Due to the subtlety of the distinction between binding and assignment, some
people have proposed that assignment be eliminated wherever possible. The
Maclisp do function can often be useful in this regard.
There are several program constructs by which a variable can be bound. These
will be explained after forms and functions have been introduced.
Page 1-14 ∪1-3.1 December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
3.2 Evaluation of Forms
The process of "executing" a Lisp program consists of the evaluation of
forms. Evaluation takes a form and produces from it a value (any Lisp object),
according to a strict set of rules which might be regarded as the complete
semantics of Lisp.
If the form is atomic, it is evaluated in a way which depends on its data
type. An atomic symbol is a variable; it evaluates to the value to which it is
currently bound. If it is not bound, an error occurs. (See part 3.4.) A number
or a string is a literal constant; it evaluates to itself. The special atomic
symbols t and nil are also treated as constants. A constant can also be created
by use of the quote special form; the value of (quote x) is x.
If the form is a list, its first element specifies the operation to be
performed, and its remaining elements specify arguments to that operation. Non-
atomic forms come in two types: special forms, which include the necessary
programming operations such as assignment and conditionals, and function
references, in which the "operation" is a function which is applied to the
specified arguments. Thus functional composition is the method by which
programs are built up out of parts - as distinguished from composition of data
structures, for example. Lisp functions correspond closely to subroutines in
other programming languages.
A function may be either a primitive which is directly executable by the
machine, called a subr (short for "subroutine"), or a function defined by
composition of functions and special forms, called an expr (short for
"expression.") Most subrs are built in to the language, but it is possible for a
user to convert his exprs into subrs by using the compiler (see part 4.) This
gains speed and compactness at some cost in debugging features.
There is additional complexity because special forms are actually implemented
as if they were function references. There is a special type of subr called an
fsubr which is used for this purpose. An fsubr is permitted to make any
arbitrary interpretation of its argument specification list, instead of
following the standard procedure which is described below. It is also possible
to define a special form by an expr, which is then called a fexpr. Most of the
built-in special forms are handled specially by the compiler. They are compiled
as the appropriate code rather than as a call to the fsubr.
Other types of functions are lsubr, which is just a subr with a variable
December 5, 1977 ∪1-3.2 Page 1-15
**DRAFT** Maclisp Reference Manual **DRAFT**
number of arguments, lexpr, which is an expr with a variable number of
arguments, and macro, which is a type of special form whose result is not a
value, but another form; this allows a "transformational" type of semantics.
Consider the form
(F A1 A2 ... An)
The evaluator first examines F to see if it is a function which defines a
special form, i.e. an fsubr, a fexpr, or a macro. If so, F is consulted and it
decides how to produce a value. If not, F must be an ordinary function. The
sub-forms A1 through An are evaluated, producing n arguments, and then the
definition of F is applied to the arguments. (Application is described in the
following section.) This yields a result (some Lisp object), which is then taken
as the value of the form.
An atomic form of some random type, such as a subr-object, a file, or an
array-pointer, evaluates to something random, often itself; or else causes an
error depending on the convenience of the implementation. Note that an array-
pointer is different from an atomic symbol which happens to be the name of an
array; such an atomic symbol is evaluated the same as any other atomic symbol.
Page 1-16 ∪1-3.2 December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
3.3 Application of Functions
When a non-atomic form is evaluated, the function specified by that form is
combined with the arguments specified by that form to produce a value. This
process is called application; the function is said to be applied to the
arguments.
The first step in application is to convert the function-specifier into a
functional expression (sometimes confusingly called a functional form.) A
functional expression is a Lisp object which is stylized so that Lisp can know
how to apply it to arguments. The rules for this conversion will be described
after the types of functional expressions have been explained.
There are basically two types of functional expression. A lambda-expression
is a functional expression which specifies some variables which are to be bound
to the arguments, and some forms which are to be evaluated. One would expect
the forms to depend on the variables. The value of the last form is used as the
value of the application of the lambda-expression. Any preceding forms are
present purely for their side-effects. A lambda-expression looks like:
(lambda (a b c d)
form1
form2
form3)
Here a, b, c, and d are the variables to be bound to the values of the
arguments, called the lambda-variables. If at a certain moment the current
binding of a was the one created by this lambda-expression, a would be said to
be lambda-bound. Clearly this lambda-expression is a function which accepts
four arguments. The application of the functional expression to four arguments
produces a value by evaluating form1, then form2, and then form3. The value of
form3 is the value of the whole form. For example, the value of the form
((lambda (a b) b) 3 4)
is 4. The functional expression used is a very simple one which accepts two
arguments and returns the second one.
If we grant the existence of a primitive addition operation, whose functional
expression may be designated by +, then the value of the form
December 5, 1977 ∪1-3.3 Page 1-17
**DRAFT** Maclisp Reference Manual **DRAFT**
((lambda (a b) (+ a b)) 3 4)
is 7. Actually,
(+ 3 4)
evaluates to the same thing.
The second basic type of functional expression is the subr, which is a
program directly executable by the machine. The arguments of the form are
conveyed to this program in a machine-dependent manner, it performs some
arbitrary computation, and it returns a result. The built in primitives of the
language are subrs, and the user may write lambda-expressions which make use of
these subrs to define his own functions. The compiler may be used to convert
user functions into subrs if extra efficiency is required.
It is extremely convenient to be able to assign names to functional
expressions. Otherwise the definition of a function would have to be written
out in full each time it was used, which would be impossibly cumbersome.
Lisp uses atomic symbols to name functions. The "property list" mechanism is
used to associate an atomic symbol with a functional expression. (See page 2-52
for an explanation of property lists.) Because the binding mechanism is not
used, it is possible for the same name to be used for both a variable and a
function with no conflict. Usually the defun special form is used to establish
the association between a function name and a functional expression.
Thus, the car of a form may be either a functional expression itself, or an
atomic symbol which names a functional expression. In the latter case, the name
of the "property" which associates the symbol with the expression gives
additional information:
A lambda-expression is normally placed under the expr property. This defines
an ordinary expr.
If a lambda-expression is placed under the fexpr property, it defines a
special form. In that case, the first lambda-variable is bound to the cdr of
the form being evaluated. For example, if foo is a fexpr, and (foo (a b) (c d))
is evaluated, then foo's lambda-variable would be bound to ((a b) (c d)). A
second lambda-variable may optionally be included in a fexpr. It will be bound
to a "binding context pointer" to the context of the evaluation of the form.
(See page 1-22 for the details of binding context pointers.)
Page 1-18 ∪1-3.3 December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
If a lambda-expression with one lambda-variable is placed under the macro
property, it defines the "macro" special form mentioned above. The lambda-
expression is applied to the entire form, as a single argument, and the value is
a new form that is evaluated in place of the original form.
If a subr-object is placed under the subr property, it defines a subr. If a
subr-object is placed under the fsubr property, it defines a special form. A
subr-object under the lsubr property defines a subr which accepts varying
numbers of arguments.
There are some additional refinements. A lambda-expression which accepts
varying numbers of arguments, called a lexpr, looks as follows:
(lambda n
form1
form2)
The single, unparenthesized, lambda-variable n is bound to the number of
arguments. The function arg, described on page 2-12, may be used to obtain the
arguments.
Another property which resembles a functional property is the autoload
property. If Lisp encounters an autoload property while searching the property
list of a symbol for functional properties, it loads in the file of compiled
functions specified by the property, then searches the property list again.
Presumably the file would contain a definition for the function being applied,
and that definition would be found the second time through. In this way
packages of functions which are not always used can be present in the
environment only when needed.
An array may also be used as a function. The arguments are the subscripts
and the value is the contents of the selected cell of the array. An atomic
symbol with an array property appearing in the function position in a form
causes that array to be used.
If the function-specifier of a form doesn't meet any of the above tests, Lisp
evaluates it and tries again. In this way, "functional variables" and "computed
functions" can be used. However, it is better to use the funcall function.
(See page 2-13.)
There are some other cases of lesser importance:
December 5, 1977 ∪1-3.3 Page 1-19
**DRAFT** Maclisp Reference Manual **DRAFT**
There is an obscure type of functional expression called a label-expression.
It looks like
(label name (lambda (...) ...))
The atomic symbol name is bound to the enclosed lambda-expression for the
duration of the application of the label-expression. Thus if name is used as a
functional variable this temporary definition will be used. This is mostly of
historical interest and is rarely used in actual programming.
Another type of functional expression is the funarg. A funarg is a list
beginning with the atomic symbol funarg, as you might expect, and containing a
function and a binding context pointer. Applying a funarg causes the contained
function to be applied in the contained binding context instead of the usual
context. funargs are created by the *function special form.
An expr property may be an atomic symbol rather than a lambda-expression. In
this case, the atomic symbol is used as the function. The original symbol is
simply a synonym for it.
In addition to the variety of application just described, which is used
internally by the evaluation procedure, there is a similar but not identical
application procedure available through the function apply. The main difference
is that the function and the arguments are passed to apply separately. They are
not encoded into a form, consequently macros are not accepted by this version of
application. Note that what is passed to apply is a list of arguments, not a
list of expressions which, evaluated, would yield arguments.
Page 1-20 ∪1-3.3 December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
3.4 Special Forms
This section briefly describes some of the special forms in Maclisp. For
full details on a specific special form, consult the Function Index in the back.
Constants
(quote x) evaluates to the S-expression x.
(function x) evaluates to the functional expression x. There is little
real difference between quote and function. The latter is simply a
mnemonic reminder to anyone who reads the program - including the compiler
- that the specified expression is supposed to be some kind of function.
Conditionals
Conditionals control whether or not certain forms are evaluated, depending
on the results of evaluating other forms. Thus both the value and the side
effects of the conditional form can be controlled.
(cond (predicate form1 form2...) (predicate form1 form2...)...)
is a general conditional form. The lists of a predicate and some forms are
called clauses. The cond is evaluated by considering the clauses one by
one in the order they are written. The predicate of a clause is evaluated,
and if the result is true, that is, anything other than nil, then the forms
in that clause are evaluated and the cond is finished without examining the
remaining clauses. If the result is not true, i.e. if it is nil, then the
next clause is examined in the same way. If all the clauses are exhausted,
that is not an error. The value of a cond is the value of the last form it
evaluates, which could be nil if no predicate is true, or the value of a
predicate if that predicate is true but has no forms in its clause.
(and form1 form2 form3...) evaluates the forms in succession until one is
nil or the forms are exhausted, and the result is the value of the last
form evaluated.
(or form1 form2 form3...) evaluates the forms until one is non-nil or the
forms are exhausted, and the result is the value of the last form
evaluated.
December 5, 1977 ∪1-3.4 Page 1-21
**DRAFT** Maclisp Reference Manual **DRAFT**
Non-Local Exits
(catch form tag) evaluates the form, but if the special form (throw value
tag) is encountered, and the tags are the same, the catch immediately
returns the value without further ado. See page 2-44 for the full details.
Iteration
(prog (variable...) form-or-tag ...) allows Fortranoid "programs" with
goto's, local variables, and return's to be written.
(do ...) is the special form for iteration. See page 2-38 for the details
of prog and do.
Defining Functions
(defun name (arg1 arg2...) form1 form2...) defines an (interpreted)
function. See page 2-60 for full details.
Error Control
(break name t) causes ";bkpt name" to be typed out and gives control to a
read-eval-print loop so that the user can examine and change the state of
the world. When he is satisfied, the user can cause the break to return a
value. See page 3-5 for the details of break.
(errset form) evaluates the form, but if an error occurs the errset simply
returns nil. If no error occurs, the value is a list whose single element
is what the value of the form would have been without errset.
Assignment
(setq var1 value1 var2 value2...) assigns the values to the variables. The
values are forms which are evaluated.
(store (array subscript1 subscript2...) value) assigns the value to the
array cell selected by subscripting. See part 2.8 for further information
on arrays.
Page 1-22 ∪1-3.4 December 5, 1977
**DRAFT** The Basic Actions of LISP **DRAFT**
Miscellaneous Parameters
(status name -optional args-) returns miscellaneous parameters of LISP.
name is a mnemonic name for what is to be done.
(sstatus name -optional args-) sets miscellaneous parameters.
See part 3.7 for the details of status and sstatus.
Pretty-Printing
(grindef x) prettily prints the value and function definition (if any) of
the atomic symbol x. Indentation is used to reveal structure, the quote
special form is represented by ', etc. See part 6.3 for the details.
Tracing
(trace name) causes the function name to print a message whenever it is
called and whenever it returns. See page 3-34 for the many features and
options of trace.
December 5, 1977 ∪1-3.4 Page 1-23
**DRAFT** Maclisp Reference Manual **DRAFT**
3.5 Binding Context Pointers
There is a special type of object called a binding context pointer, or
sometimes an "a-list pointer", which can be used to refer to a binding context
(a set of bindings of variables and values which was extant at a particular
instant.) Due to the stack implementation of Maclisp, a binding context pointer
is only valid while control is nested within the binding context it names. It
is not possible to exit from within a binding context but keep it around by
retaining a pointer to it.
A binding context pointer is either a negative fixnum or nil. nil means the
"global" or "top level" binding context. The negative fixnum is a special value
of implementation dependent meaning which should be obtained only from one of
the four following sources: the function evalframe, the function errframe, the
special form *function, or the second lambda-variable of a fexpr.
The only use for binding context pointers is to pass them to the functions
eval and apply to specify the binding context in which variables are to be
evaluated and assignments are to be performed during that evaluation or
application. Binding context pointers are also used internally by *function.
When it generates a funarg, it puts in the funarg the functional expression it
was given and a binding context pointer designating the binding environment
current at the time *function was called.
Page 1-24 ∪1-3.5 December 5, 1977
**DRAFT** Function Descriptions **DRAFT**
Part 2 - Function Descriptions
Table of Contents
1. Predicates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-1
2. The Evaluator . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-7
3. Manipulating List Structure . . . . . . . . . . . . . . . . . . . .2-15
3.1 Conses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-15
3.2 Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-18
3.3 Alteration of List Structure . . . . . . . . . . . . . . . . . . . .2-23
3.4 Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-25
3.5 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-31
3.6 Hunks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-33
4. Flow of Control . . . . . . . . . . . . . . . . . . . . . . . . . .2-35
4.1 Conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-36
4.2 Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-38
4.3 Non-local Exits . . . . . . . . . . . . . . . . . . . . . . . . . .2-44
4.4 Causing and Controlling Errors . . . . . . . . . . . . . . . . . . .2-46
5. Atomic Symbols . . . . . . . . . . . . . . . . . . . . . . . . . . .2-49
5.1 The Value Cell . . . . . . . . . . . . . . . . . . . . . . . . . . .2-49
5.2 The Property List . . . . . . . . . . . . . . . . . . . . . . . . .2-52
5.3 The Print-Name . . . . . . . . . . . . . . . . . . . . . . . . . . .2-56
5.4 Interning of Symbols . . . . . . . . . . . . . . . . . . . . . . . .2-58
5.5 Defining Atomic Symbols as Functions . . . . . . . . . . . . . . . .2-61
6. Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-65
6.1 Number Predicates . . . . . . . . . . . . . . . . . . . . . . . . .2-65
6.2 Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-67
6.3 Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-69
6.4 Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-71
6.5 Exponentiation and Logarithm Functions . . . . . . . . . . . . . . .2-79
6.6 Trigonometric Functions . . . . . . . . . . . . . . . . . . . . . .2-80
6.7 Random Functions . . . . . . . . . . . . . . . . . . . . . . . . . .2-81
6.8 Logical Operations on Numbers . . . . . . . . . . . . . . . . . . .2-82
7. Character Manipulation . . . . . . . . . . . . . . . . . . . . . . .2-85
7.1 Character Objects . . . . . . . . . . . . . . . . . . . . . . . . .2-85
December 5, 1977 Page 2-1
**DRAFT** Maclisp Reference Manual **DRAFT**
7.2 Character Strings . . . . . . . . . . . . . . . . . . . . . . . . .2-89
8. Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-91
9. Mapping Functions . . . . . . . . . . . . . . . . . . . . . . . . .2-99
Page 2-2 December 5, 1977
**DRAFT** Predicates **DRAFT**
1. Predicates
A predicate is a function which tests for some condition involving its
argument and returns t if that condition is true, or nil if it is not true.
The following predicates are for checking data types. These predicates
return t if their argument is of the type indicated by the name of the function,
nil if it is of some other type. Note that the name of most predicates ends in
the letter p, by convention.
atom SUBR 1 arg
The atom predicate returns nil if its argument is a dotted-pair or a list,
or t if it is any kind of atomic object such as a number, a character
string, or an atomic symbol.
symbolp SUBR 1 arg
The symbolp predicate returns t if its argument is an atomic symbol, or nil
if it is anything else.
fixp SUBR 1 arg
The fixp predicate returns t if its argument is a fixnum or a bignum,
otherwise nil.
floatp SUBR 1 arg
The floatp predicate returns t if its argument is a flonum, nil if it is
not.
bigp SUBR 1 arg
The predicate bigp returns t if its argument is a bignum, and nil
otherwise.
December 5, 1977 ∪2-1. Page 2-1
**DRAFT** Maclisp Reference Manual **DRAFT**
numberp SUBR 1 arg
The numberp predicate returns t if its argument is any kind of number, nil
if it is not.
hunkp SUBR 1 arg
The hunkp predicate returns t if its argument is a hunk (see page 2-33 for
a discussion of hunks). hunkp does not consider list cells to be hunks.
This predicate does not exist in the Multics implementation.
typep SUBR 1 arg
typep is a general function for constructing type-predicates. It returns
an atomic symbol describing the type of its argument, chosen from the list
(fixnum flonum bignum list symbol string array random)
symbol means atomic symbol. list means a list or a cons. array means
array-pointer. random is for all types that don't fit in any other
category. Thus numberp could have been defined by:
(defun numberp (x)
(and (memq (typep x) '(fixnum flonum bignum))
t))
The following two functions only exist in the Multics implementation.
stringp SUBR 1 arg
The stringp predicate returns t if its argument is a string, otherwise nil.
subrp SUBR 1 arg
The subrp predicate returns t if its argument is a "subr" object, i.e. a
pointer to the machine code for a compiled or system function. Example:
(subrp (get 'car 'subr)) => t
Page 2-2 ∪2-1. December 5, 1977
**DRAFT** Predicates **DRAFT**
The following are a more miscellaneous set of predicates.
eq SUBR 2 args
(eq x y) => t if x and y are exactly the same object, nil otherwise (cf.
equal). It should be noted that things that print the same are not
necessarily eq to each other. In particular, numbers with the same value
need not be eq, and two similar lists are usually not eq. In general, two
atomic symbols with the same print-name are eq, but it is possible with
maknam or multiple obarrays to generate symbols which have the same print-
name but are not eq. Examples:
(eq 'a 'b) => nil
(eq 'a 'a) => t
(eq '(a . b) '(a . b)) => nil (usually)
(eq (cons 'a 'b) (cons 'a 'b)) => nil (always)
(setq x '(a . b)) (eq x x) => t since it is
the same copy of (a . b) in both arguments.
(setq x (setq y 17)) (eq x y) => t or nil
depending on the implementation. You can
never rely on numbers being eq.
equal SUBR 2 args
The equal predicate returns t if its arguments are similar (isomorphic)
objects. (cf. eq) Two numbers are equal if they have the same value (a
flonum is never equal to a fixnum though). Two strings are equal if they
have the same length, and the characters composing them are the same. All
other atomic objects are equal if and only if they are eq. For dotted
pairs and lists, equal is defined recursively as the two car's being equal
and the two cdr's being equal. Thus equal could have been defined by:
December 5, 1977 ∪2-1. Page 2-3
**DRAFT** Maclisp Reference Manual **DRAFT**
(defun equal (x y)
(or (eq x y)
(and (numberp x) (numberp y) (numequal x y))
(and (not (atom x))
(not (atom y))
(equal (car x) (car y))
(equal (cdr x) (cdr y)))))
if there was an auxiliary function for numeric equality:
(defun numequal (x y)
(and (eq (typep x) (typep y))
(zerop (difference x y))))
This numequal function is not the same as the Maclisp numeric-equality
function, =, because the latter only compares non-big numbers.
As a consequence of the above definition, it can be seen that equal need
not terminate when applied to looped list structure. In addition, eq
always implies equal. An intuitive definition of equal (which is not quite
correct) is that two objects are equal if they look the same when printed
out.
not SUBR 1 arg
not returns t if its argument is nil, otherwise nil.
null SUBR 1 arg
This is the same as not. Both functions are provided for the sake of
clarity. null should be used to check if something is nil and return a
logical value. not should be used to invert the sense of a logical value.
Even though Lisp uses nil to represent logical "false," you shouldn't make
understanding your program depend on this. For example, one often writes
(cond ((not (null x)) ... )
( ... ))
Page 2-4 ∪2-1. December 5, 1977
**DRAFT** Predicates **DRAFT**
rather than
(cond (x ... )
( ... ))
There is no loss of efficiency since these will compile into exactly the
same instructions.
See also the number predicates (page 2-63).
December 5, 1977 ∪2-1. Page 2-5
**DRAFT** Maclisp Reference Manual **DRAFT**
Page 2-6 ∪2-1. December 5, 1977
**DRAFT** The Evaluator **DRAFT**
2. The Evaluator
eval LSUBR 1 or 2 args
(eval x) evaluates x, as a form, atomic or otherwise, and returns the
result.
(eval x p) evaluates x in the context specified by the binding context
pointer p. Example:
(setq x 43 foo 'bar)
(eval (list 'cons x 'foo))
=> (43 . bar)
apply LSUBR 2 or 3 args
(apply f y) applies the function f to the list of arguments y. Unless f is
an fsubr or fexpr, such as cond or and, which evaluates its arguments in a
funny way, the arguments in the list y are used without being evaluated.
Examples:
(setq f '+) (apply f '(1 2 3)) => 6
(setq f '-) (apply f '(1 2 3)) => -4
(apply 'cons '((+ 2 3) 4)) =>
((+ 2 3) . 4) not (5 . 4)
(apply f y p) works like apply with two arguments except that the
application is done with the variable bindings specified by the binding
context pointer p.
quote FSUBR
The special form (quote x) returns x without trying to evaluate it. quote
is used to include constants in a form. For convenience, the read function
normally converts any S-expression preceded by the apostrophe or acute
accent character (') into the quote special form. For example,
December 5, 1977 ∪2-2. Page 2-7
**DRAFT** Maclisp Reference Manual **DRAFT**
(setq x '(some list))
is converted by the reader to:
(setq x (quote (some list)))
which when evaluated causes the variable x to be set to the constant list
value shown. For more information on input syntax, see the detailed
discussion in part 5.1.
quote could have been defined by:
(defun quote fexpr (x) (car x))
function FSUBR
function is like quote except that its argument is a functional expression.
To the interpreter, quote and function are identical, but the compiler
needs to be able to distinguish between a random piece of data, which
should be left alone, and a function, which should be compiled into machine
code. Example:
(mapcar (function (lambda (p q)
(cond ((eq p '*) q)
(t (list p '= q)) )))
first-list-of-things
(compute-another-list) )
calls mapcar with three arguments, the first of which is the function
defined by the lambda-expression. The actual value passed to mapcar
depends on whether the form has been compiled. If it is interpreted, the
lambda-expression written above will be passed. If it is compiled, an
automatically-generated atomic symbol with the compiled code for the
lambda-expression as its subr property will be passed. The usual thing to
do with functional arguments is to invoke them via apply or funcall, which
accept both the compiled and the interpreted functional forms.
function makes no attempt to solve the "funarg problem." *function should
be used for this purpose.
Page 2-8 ∪2-2. December 5, 1977
**DRAFT** The Evaluator **DRAFT**
*function FSUBR
The value of (*function f) is a "funarg" of the function f. A funarg can
be used like a function. It has the additional property that it contains a
binding context pointer so that the values of variables are bound the same
during the application of the funarg as at the time it was created,
provided that the binding environment in which the funarg was created still
exists on the stack. Hence if foo is a function that accepts a functional
argument, such as
(defun foo (f)
(append one-value (f the-other-value) ))
or, better
(defun foo (f)
(append one-value (funcall f the-other-value) ))
then
(foo (*function bar))
works, but
(foo (prog (x y z)
(do something)
(return (*function bar)) ))
does not if bar intends to reference the prog variables x, y, and z.
*function is intended to help solve the "funarg problem," however it only
works in some easy cases. Funargs generated by *function are intended for
use as functional arguments and cannot be returned as values of functional
applications. Thus, the user should be careful in his use of *function to
make sure that his use does not exceed the limitations of the Maclisp
funarg mechanism.
It is possible to assign a value to a variable when a previous binding of
that variable has been made current by a funarg. The assignment will be
executed in the proper context. (This has not always been the case in
Maclisp; it is a fairly new feature.)
A funarg has the form
(funarg function . context-ptr)
December 5, 1977 ∪2-2. Page 2-9
**DRAFT** Maclisp Reference Manual **DRAFT**
comment FSUBR
comment ignores its arguments and returns the atomic symbol comment.
Example:
(defun foo (x)
(cond ((null x) 0)
(t (comment x has something in it)
(1+ (foo (cdr x))))))
Usually it is preferable to comment code using the semicolon-macro feature
of the standard input syntax. This allows the user to add comments to his
code which are ignored by the lisp reader.
Example:
(defun foo (x)
(cond ((null x) 0)
(t (1+ (foo (cdr x)))) ;x has something in it
))
A problem with such comments is that they are discarded when the S-
expression is read into lisp. If it is edited within lisp and printed back
into a file, the comments will be lost. However, most users edit the
original file and read the changes into lisp, since this allows them to use
the editor of their choice. Thus this is not a real problem.
prog2 LSUBR 2 or more args
The expressions in a prog2 form are evaluated from left to right, as in any
lsubr-form. The result is the second argument. prog2 is most commonly
used to evaluate an expression with side effects, then return a value which
needs to be computed before the side effects happen.
Examples:
(prog2 (do-this) (do-that)) ;just get 2 things evaluated
(setq x (prog2 nil y ;parallel assignment
(setq y x))) ;which exchanges x and y
(defun prog2 nargs (arg 2)) ;a lexpr definition for prog2
Page 2-10 ∪2-2. December 5, 1977
**DRAFT** The Evaluator **DRAFT**
progn LSUBR 1 or more args
The expressions in a progn form are evaluated from left to right, as usual,
and the result is the value of the last one. In other words, progn is an
lsubr which does nothing but return its last argument. Although lambda-
expressions, prog-forms, do-forms, cond-forms, and iog-forms all use progn
implicitly, that is, they allow multiple forms in their bodies, there are
occasions when one needs to evaluate a number of forms for side-effects and
make them appear to be a single form. progn serves this purpose. Example:
(progn (setq a (cdr frob)) (eq (car a) (cadr a)))
might be used as the antecedent of a cond clause.
progn could have been defined by:
(defun progn nargs
(and (> nargs 0)
(arg nargs)))
progv FSUBR
progv is a special form to provide the user with extra control over lambda-
binding. It binds a list of variables to a list of values, and then
evaluates some forms. The lists of variables and values are computed
quantities; this is what makes progv different from lambda, prog, and do.
(progv var-list value-list form1 form2 ... )
first evaluates var-list and value-list. Then the variables are bound to
the values. In compiled code the variables must be special, since the
compiler has no way of knowing what symbols might appear in the var-list.
If too few values are supplied, the remaining variables are bound to nil.
If too many values are supplied, the excess values are ignored.
After the variables have been bound to the values, the forms are evaluated,
and finally the variable bindings are undone. The result returned is the
value of the last form. Note that the "body" of a progv is similar to that
of progn, not that of prog.
Example:
December 5, 1977 ∪2-2. Page 2-11
**DRAFT** Maclisp Reference Manual **DRAFT**
(setq a 'foo b 'bar)
(progv (list a b 'b) (list b) (list a b foo bar))
=> (foo nil bar nil)
During the evaluation of the body of this progv, foo is bound to bar, bar
is bound to nil, b is bound to nil, and a remains bound to foo.
arg SUBR 1 arg
(arg nil), when evaluated during the application of a lexpr, gives the
number of arguments supplied to that lexpr. This is primarily a debugging
aid, since lexprs also receive their number of arguments as the value of
their lambda-variable.
(arg i), when evaluated during the application of a lexpr, gives the value
of the i'th argument to the lexpr. i must be a fixnum in this case. It is
an error if i is less than 1 or greater than the number of arguments
supplied to the lexpr.
Example:
(defun foo nargs ;define a lexpr foo.
(print (arg 2)) ;print the second argument.
(+ (arg 1) ;return the sum of the first
(arg (- nargs 1)))) ;and next to last arguments.
setarg SUBR 2 args
setarg is used only during the application of a lexpr. (setarg i x) sets
the lexpr's i'th argument to x. i must be greater than zero and not
greater than the number of arguments passed to the lexpr. After (setarg i
x) has been done, (arg i) will return x.
Page 2-12 ∪2-2. December 5, 1977
**DRAFT** The Evaluator **DRAFT**
listify SUBR 1 arg
(listify n) efficiently manufactures a list of n of the arguments of a
lexpr. With a positive argument n, it returns a list of the first n
arguments of the lexpr. With a negative argument n, it returns a list of
the last (abs n) arguments of the lexpr. Basically, it works as if defined
as follows:
(defun listify (n)
(cond ((minusp n)
(listify1 (arg nil) (+ (arg nil) n 1)))
(t
(listify1 n 1)) ))
(defun listify1 (n m) ; auxiliary function.
(do ((i n (1- i))
(result nil (cons (arg i) result)))
((< i m) result) ))
funcall LSUBR 1 or more args
(funcall f a1 a2 ... an) calls the function f with the arguments a1, a2,
..., an. It is similar to apply except that the separate arguments are
given to funcall, rather than a list of arguments. If f is a fexpr or an
fsubr there must be exactly one argument. f may not be a macro. Example:
(setq cons 'plus)
(cons 1 2) => (1 . 2)
(funcall cons 1 2) => 3
subrcall FSUBR
subrcall is used to invoke a subr-pointer directly, rather than by
referring to an atomic symbol of which the subr-pointer is the subr
property. The form is:
(subrcall type p a1 a2 ... an)
All arguments except the first are evaluated. type is the type of result
expected: fixnum, flonum, or nil (any type). p is the subr pointer to be
December 5, 1977 ∪2-2. Page 2-13
**DRAFT** Maclisp Reference Manual **DRAFT**
called. a1 through an are the arguments to be passed to the subr.
subrcall compiles into efficient machine code.
lsubrcall FSUBR
lsubrcall is identical to subrcall except that the subr-pointer called has
to be an lsubr instead of a subr. This is because many Lisps use different
internal calling sequences for lsubrs than for subrs.
arraycall FSUBR
arraycall is similar to subrcall and lsubrcall except that an array-pointer
is used instead of a subr-pointer. The first argument of arraycall must
correspond to the type that the array was given when it was created. An
arraycall expression may be used as the first argument to store.
Page 2-14 ∪2-2. December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
3. Manipulating List Structure
3.1 Conses
car SUBR 1 arg
Returns the first component of a cons.
Example: (car '(a b)) => a
cdr SUBR 1 arg
Returns the second component of a cons.
Example: (cdr '(a b c)) => (b c)
car SWITCH
cdr SWITCH
Officially car and cdr are only applicable to lists. However, as a matter
of convenience the car and cdr of nil are nil. This allows programs to car
and cdr off the ends of lists without having to check, which is sometimes
helpful. Furthermore, some old programs apply car and cdr to objects other
than lists in order to hack with the internal representation. To provide
control over this, the value of car can be set to control which data types
are subject to the car operation. Similarly, the value of cdr controls the
cdr operation. Illegal operations will cause errors. For reasons of
efficiency, this error checking is only enabled in (*rset t) mode (see page
3-28) and is mostly turned off in compiled programs. The values tk which
the switches may be set are:
December 5, 1977 ∪2-3. Page 2-15
**DRAFT** Maclisp Reference Manual **DRAFT**
Value Operation applicable to
list lists.
nil lists and nil.
symbol lists, nil, and symbols.
t anything.
The default value of the switches is nil.
c...r SUBR 1 arg
All the compositions of up to four car's and cdr's are defined as functions
in their own right. The names begin with c and end with r, and in between
is a sequence of a's and d's corresponding to the composition performed by
the function.
For example,
(cddadr x) = (cdr (cdr (car (cdr x))))
Some of the most commonly used ones are: cadr, which gets the second
element of a list; caddr, which gets the third element of a list; cadddr,
which gets the fourth element of a list; caar, to car twice.
The car'ing and cdr'ing operations of these functions have error checking
under the control of the car and cdr switches explained above, just as the
car and cdr functions themselves do.
cons SUBR 2 args
This is a primitive function to construct a new dotted pair whose car is
the first argument to cons, and whose cdr is the second argument to cons.
Thus the following identities hold (except when numbers are involved; as
always numbers are not well-behaved with respect to eq):
(eq (car (cons x y)) x) => t
(eq (cdr (cons x y)) y) => t
Page 2-16 ∪2-3.1 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
Examples:
(cons 'a 'b) => (a . b)
(cons 'a (cons 'b (cons 'c nil))) => (a b c)
(cons 'a '(b c d e f)) => (a b c d e f)
ncons SUBR 1 arg
(ncons x) = (cons x nil) = (list x)
xcons SUBR 2 args
xcons ("exchange cons") is like cons except that the order of arguments is
reversed.
Example:
(xcons 'a 'b) => (b . a)
December 5, 1977 ∪2-3.1 Page 2-17
**DRAFT** Maclisp Reference Manual **DRAFT**
3.2 Lists
last SUBR 1 arg
last returns the last cons of the list which is its argument.
Example:
(setq x '(a b c d))
(last x) => (d)
(rplacd (last x) '(e f))
x => (a b c d e f)
last could have been defined by:
(defun last (x)
(cond ((null x) x)
((null (cdr x)) x)
((last (cdr x))) ))
In some implementations, the null check above may be replaced by an atom
check, which will catch dotted lists. Code which depends on this fact
should not be written though, because all implementations are subject to
change on this point.
length SUBR 1 arg
length returns the length of its argument, which must be a list. The
length of a list is the number of top-level conses in it.
Examples:
(length nil) => 0
(length '(a b c d)) => 4
(length '(a (b c) d)) => 3
length could have been defined by:
Page 2-18 ∪2-3.2 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
(defun length (x)
(cond ((null x) 0)
((1+ (length (cdr x)))) ))
or by:
(defun length (x)
(do ((n 0 (1+ n))
(y x (cdr y)))
((null y) n) ))
The warning about dotted lists given under last applies also to length.
list LSUBR 0 or more args
list constructs and returns a list of its arguments.
Example:
(list 3 4 'a (car '(b . c)) (+ 6 -2)) => (3 4 a b 4)
list could have been defined by:
(defun list nargs
(do ((n nargs (1- n))
(s nil (cons (arg n) s)))
((zerop n) s) ))
(This depends on parallel assignment to the control variables of do.)
append LSUBR 0 or more args
The arguments to append are lists. The result is a list which is the
concatenation of the arguments. The arguments are not changed (cf. nconc).
For example,
(append '(a b c) '(d e f) nil '(g)) => (a b c d e f g)
To make a copy of the top level of a list, that is, to copy the list but
not its elements, use (append x nil).
December 5, 1977 ∪2-3.2 Page 2-19
**DRAFT** Maclisp Reference Manual **DRAFT**
A version of append which only accepts two arguments could have been
defined by:
(defun append2 (x y)
(cond ((null x) y)
((cons (car x) (append2 (cdr x) y)) )))
The generalization to any number of arguments could then be made using a
lexpr:
(defun append argcount
(do ((i (1- argcount) (1- i))
(val (arg argcount) (append2 (arg i) val)))
((zerop i) val) ))
reverse SUBR 1 arg
Given a list as argument, reverse creates a new list whose elements are the
elements of its argument taken in reverse order. reverse does not modify
its argument, unlike nreverse which is faster but does modify its argument.
Example:
(reverse '(a b (c d) e)) => (e (c d) b a)
reverse could have been defined by:
(defun reverse (x)
(do ((l x (cdr l)) ; scan down argument,
(r nil ; putting each element
(cons (car l) r))) ; into list, until
((null l) r))) ; no more elements.
nconc LSUBR 0 or more args
nconc takes lists as arguments. It returns a list which is the arguments
concatenated together. The arguments are changed, rather than copied.
(cf. append)
Example:
(nconc '(a b c) '(d e f)) => (a b c d e f)
Page 2-20 ∪2-3.2 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
Note that the constant (a b c) has now been changed to (a b c d e f). If
this form is evaluated again, it will yield (a b c d e f d e f). This is a
danger you always have to watch out for when using nconc.
nconc could have been defined by:
(defun nconc (x y) ;for simplicity, this definition
(cond ((null x) y) ;only works for 2 arguments.
(t (rplacd (last x) y) ;hook y onto x
x))) ;and return the modified x.
nreverse SUBR 1 arg
nreverse reverses its argument, which should be a list. The argument is
destroyed by rplacd's all through the list (cf. reverse).
Example:
(nreverse '(a b c)) => (c b a)
nreverse could have been defined by:
(defun nreverse (x)
(cond ((null x) nil)
((nreverse1 x nil))))
(defun nreverse1 (x y) ;auxiliary function
(cond ((null (cdr x)) (rplacd x y))
((nreverse1 (cdr x) (rplacd x y)))))
;; this last call depends on order of argument evaluation.
nreconc SUBR 2 args
(nreconc x y) is exactly the same as (nconc (nreverse x) y) except that it
is more efficient.
nreconc could have been defined by:
(defun nreconc (x y)
(cond ((null x) y)
((nreverse1 x y)) ))
December 5, 1977 ∪2-3.2 Page 2-21
**DRAFT** Maclisp Reference Manual **DRAFT**
using the same nreverse1 as above.
Page 2-22 ∪2-3.2 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
3.3 Alteration of List Structure
The functions rplaca and rplacd are used to make alterations in already-
existing list structure. The structure is not copied but physically altered;
hence caution should be exercised when using these functions as strange side-
effects can occur if portions of list structure become shared unbeknownst to the
programmer. The nconc, nreverse, and nreconc functions already described have
the same property. However, they are normally not used for this side-effect;
rather, the list-structure modification is purely for efficiency and compatible
non-modifying functions are provided.
rplaca SUBR 2 args
(rplaca x y) changes the car of x to y and returns (the modified) x.
Example:
(setq g '(a b c))
(rplaca (cdr g) 'd) => (d c)
Now g => (a d c)
rplacd SUBR 2 args
(rplacd x y) changes the cdr of x to y and returns (the modified) x.
Example:
(setq x '(a b c))
(rplacd x 'd) => (a . d)
Now x => (a . d)
See also setplist (page 2-55).
December 5, 1977 ∪2-3.3 Page 2-23
**DRAFT** Maclisp Reference Manual **DRAFT**
subst SUBR 3 args
(subst x y z) substitutes x for all occurrences of y in z, and returns the
modified copy of z. The original z is unchanged, as subst recursively
copies all of z replacing elements eq to y as it goes. If x and y are nil,
z is just copied, which is a convenient way to copy arbitrary list
structure.
Example:
(subst 'Tempest 'Hurricane
'(Shakespeare wrote (The Hurricane)))
=> (Shakespeare wrote (The Tempest))
subst could have been defined by:
(defun subst (x y z)
(cond ((eq z y) x) ;if item eq to y, replace.
((atom z) z) ;if no substructure, return arg.
((cons (subst x y (car z)) ;otherwise recurse.
(subst x y (cdr z))))))
sublis SUBR 2 args
sublis makes substitutions for atomic symbols in an S-expression. The
first argument to sublis is an association list (see the next section).
The second argument is the S-expression in which substitutions are to be
made. sublis looks at all atomic symbols in the S-expression; if an atomic
symbol appears in the association list occurrences of it are replaced by
the object it is associated with. The argument is not modified; new conses
are created where necessary and only where necessary, so the newly created
structure shares as much of its substructure as possible with the old. For
example, if no substitutions are made, the result is eq to the old S-
expression.
Example:
(sublis '((x . 100) (z . zprime))
'(plus x (minus g z x p) 4))
=> (plus 100 (minus g zprime 100 p) 4)
In some implementations sublis works by putting temporary sublis properties
on the atomic symbols in the dotted pairs, so beware.
Page 2-24 ∪2-3.3 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
3.4 Tables
Maclisp includes several functions which simplify the maintenance of tabular
data structures of several varieties. The simplest is a plain list of items,
which models (approximately) the concept of a set. There are functions to add
(cons), remove (delete, delq), and search for (member, memq) items in a list.
Association lists are very commonly used. An association list is a list of
dotted pairs. The car of each pair is a "key" and the cdr is "data". The
functions assoc and assq may be used to retrieve the data, given the key.
Structured records can be stored as association lists or as stereotyped S-
expressions where each element of the structure has a certain car-cdr path
associated with it. There are no built-in functions for these but it easy to
define macros to implement them (see part 6.2).
Simple list-structure is very convenient, but may not be efficient enough for
large data bases because it takes a long time to search a long list. Maclisp
includes some hashing functions (sxhash, maknum) which aid in the construction
of more efficient, hairier structures.
member SUBR 2 args
(member x y) returns nil if x is not a member of the list y. Otherwise, it
returns the portion of y beginning with the first occurrence of x. The
comparison is made by equal. y is searched on the top level only.
Example:
(member 'x '(1 2 3 4)) => nil
(member 'x '(a (x y) c x d e x f)) => (x d e x f)
Note that the value returned by member is eq to the portion of the list
beginning with x. Thus rplaca on the result of member may be used, if you
first check to make sure member did not return nil.
Example:
(catch (rplaca (or (member x z)
(throw nil lose))
y)
lose)
December 5, 1977 ∪2-3.4 Page 2-25
**DRAFT** Maclisp Reference Manual **DRAFT**
member could have been defined by:
(defun member (x y)
(cond ((null y) nil)
((equal x (car y)) y)
((member x (cdr y))) ))
memq SUBR 2 args
memq is like member, except eq is used for the comparison, instead of
equal. memq could have been defined by:
(defun memq (x y)
(cond ((null y) nil)
((eq x (car y)) y)
((memq x (cdr y))) ))
delete LSUBR 2 or 3 args
(delete x y) returns the list y with all top-level occurrences of x
removed. equal is used for the comparison. The argument y is actually
modified (rplacd'ed) when instances of x are spliced out. delete should be
used for value, not for effect. That is, use
(setq a (delete 'b a))
rather than
(delete 'b a))
The latter is not equivalent when the first element of the value of a is
b.
(delete x y n) is like (delete x y) except only the first n instances of x
are deleted. n is allowed to be zero. If n is greater than the number of
occurrences of x in the list, all occurrences of x in the list will be
deleted.
Example:
Page 2-26 ∪2-3.4 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
(delete 'a '(b a c (a b) d a e)) => (b c (a b) d e)
delete could have been defined by:
(defun delete nargs ; lexpr for 2 or 3 args
(delete1 (arg 1) ; pass along arguments...
(arg 2)
(cond ((= nargs 3) (arg 3))
(123456789.)))) ; infinity
(defun delete1 (x y n) ;auxiliary function
(cond ((or (null y) (zerop n)) y)
((equal x (car y)) (delete1 x
(cdr y)
(1- n)))
((rplacd y (delete1 x (cdr y) n)))))
delq LSUBR 2 or 3 args
delq is the same as delete except that eq is used for the comparison
instead of equal.
sxhash SUBR 1 arg
sxhash computes a hash code of an S-expression, and returns it as a fixnum,
which may be positive or negative. A property of sxhash is that (equal x
y) implies (= (sxhash x) (sxhash y)). The number returned by sxhash is
some possibly large number in the range allowed by fixnums. It is
guaranteed that:
1) sxhash for an atomic symbol will always be positive.
2) sxhash of any particular expression will be constant in a particular
implementation for all time, probably.
3) Two different implementations may hash the same expression into
different values.
4) sxhash of any object of type random will be zero.
December 5, 1977 ∪2-3.4 Page 2-27
**DRAFT** Maclisp Reference Manual **DRAFT**
5) sxhash of a fixnum will = that fixnum.
Here is an example of how to use sxhash in maintaining
hash tables of S-expressions:
(defun knownp (x) ;look up x in the table
(prog (i bkt)
(setq i (plus 76 (remainder (sxhash x) 77)))
;The remainder should be reasonably randomized between
;-76 and 76, thus table size must be > 175 octal.
(setq bkt (table i))
;bkt is thus a list of all those expressions that hash
;into the same number as does x.
(return (member x bkt))))
To write an "intern" for S-expressions, one could
(defun sintern (x)
(prog (bkt i tem)
(setq bkt (table (setq i (+ 2n-2 (\ (sxhash x) 2n-1)))))
;2n-1 and 2n-1 stand for a power of 2 minus one and
;minus two respectively. This is a good choice to
;randomize the result of the remainder operation.
(return (cond ((setq tem (member x bkt))
(car tem))
(t (store (table i) (cons x bkt))
x)))))
assoc SUBR 2 args
(assoc x y) looks up x in the association list (list of dotted pairs) y.
The value is the first dotted pair whose car is equal to x, or nil if there
is none such.
Examples:
(assoc 'r '((a . b) (c . d) (r . x) (s . y) (r . z)))
=> (r . x)
(assoc 'fooo '((foo . bar) (zoo . goo))) => nil
It is okay to rplacd the result of assoc as long as it is not nil, if your
intention is to "update" the "table" that was assoc's second argument.
Page 2-28 ∪2-3.4 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
Example:
(setq values '((x . 100) (y . 200) (z . 50)))
(assoc 'y values) => (y . 200)
(rplacd (assoc 'y values) 201)
(assoc 'y values) => (y . 201) now
(One should always be careful about using rplacd however)
A typical trick is to say (cdr (assoc x y)). Since the cdr of nil is
guaranteed to be nil, this yields nil if no pair is found (or if a pair is
found whose cdr is nil.)
assoc could have been defined by:
(defun assoc (x y)
(cond ((null y) nil)
((equal x (caar y)) (car y))
((assoc x (cdr y))) ))
assq SUBR 2 args
assq is like assoc except that the comparison uses eq instead of equal.
assq could have been defined by:
(defun assq (x y)
(cond ((null y) nil)
((eq x (caar y)) (car y))
((assq x (cdr y))) ))
sassoc SUBR 3 args
(sassoc x y z) is like (assoc x y) except that if x is not found in y,
instead of returning nil sassoc calls the function z with no arguments.
sassoc could have been defined by:
(defun sassoc (x y z)
(or (assoc x y)
(apply z nil)))
sassoc and sassq (see below) are of limited use. These are primarily
leftovers from Lisp 1.5.
December 5, 1977 ∪2-3.4 Page 2-29
**DRAFT** Maclisp Reference Manual **DRAFT**
sassq SUBR 3 args
(sassq x y z) is like (assq x y) except that if x is not found in y,
instead of returning nil sassq calls the function z with no arguments.
sassq could have been defined by:
(defun sassq (x y z)
(or (assq x y)
(apply z nil)))
maknum SUBR 1 arg
(maknum x) returns a positive fixnum which is unique to the object x; that
is, (maknum x) and (maknum y) are numerically equal if and only if (eq x
y). This can be used in hashing.
In the pdp-10 implementations, maknum returns the memory address of its
argument. In the Multics implementation, an internal hash table is
employed.
Note that unlike sxhash, maknum will not return the same value on an
expression which has been printed out and read back in again.
munkam SUBR 1 arg
munkam is the opposite of maknum. Given a number, it returns the object
which was given to maknum to get that number. It is inadvisable to apply
munkam to a number which did not come from maknum.
Page 2-30 ∪2-3.4 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
3.5 Sorting
Several functions are provided for sorting arrays and lists. These functions
use algorithms which always terminate no matter what sorting predicate is used,
provided only that the predicate always terminates. The array sort is not
necessarily stable, that is equal items may not stay in their original order.
However the list sort is stable.
After sorting, the argument (be it list or array) is rearranged internally so
as to be completely ordered. In the case of an array argument, this is
accomplished by permuting the elements of the array, while in the list case, the
list is reordered by rplacd's in the same manner as nreverse. Thus if the
argument should not be clobbered, the user must sort a copy of the argument,
obtainable by fillarray or append, as appropriate.
Should the comparison predicate cause an error, such as a wrong type argument
error, the state of the list or array being sorted is undefined. However, if
the error is corrected the sort will, of course, proceed correctly.
Both sort and sortcar handle the case in which their second argument is the
function alphalessp in a more efficient manner than usual. This efficiency is
primarily due to elimination of argument checks at comparison time.
sort SUBR 2 args
The first argument to sort is an array (or list), the second a predicate of
two arguments. Note that a "number array" cannot be sorted. The predicate
must be applicable to all the objects in the array or list. The predicate
should take two arguments, and return non-nil if and only if the first
argument is strictly less than the second (in some appropriate sense).
The sort function proceeds to sort the contents of the array or list under
the ordering imposed by the predicate, and returns the array or list
modified into sorted order, i.e. its modified first argument. Note that
since sorting requires many comparisons, and thus many calls to the
predicate, sorting will be much faster if the predicate is a compiled
function rather than interpreted.
December 5, 1977 ∪2-3.5 Page 2-31
**DRAFT** Maclisp Reference Manual **DRAFT**
Example:
(defun mostcar (x)
(cond ((atom x) x)
((mostcar (car x)))))
(sort 'fooarray
(function (lambda (x y)
(alphalessp (mostcar x) (mostcar y)))))
If fooarray contained these items before the sort:
(Tokens (The lion sleeps tonight))
(Carpenters (Close to you))
((Rolling Stones) (Brown sugar))
((Beach Boys) (I get around))
(Beatles (I want to hold your hand))
then after the sort fooarray would contain:
((Beach Boys) (I get around))
(Beatles (I want to hold your hand))
(Carpenters (Close to you))
((Rolling Stones) (Brown sugar))
(Tokens (The lion sleeps tonight))
sortcar SUBR 2 args
sortcar is exactly like sort, but the items in the array or list being
sorted should all be non-atomic. sortcar takes the car of each item before
handing two items to the predicate. Thus sortcar is to sort as mapcar is
to maplist.
Page 2-32 ∪2-3.5 December 5, 1977
**DRAFT** Manipulating List Structure **DRAFT**
3.6 Hunks
This section applies only to the pdp10 implementation.
Hunks are a generalization of conses, useful in constructing more efficient
data structures. A hunk is like a cons but it has more components; hunks come
in several convenient sizes. The advantage of an n-element hunk over an n-
element list is that the hunk occupies less space (half as much if n is a power
of 2). The elements of a hunk can be referenced more efficiently than the
elements of a list, since the compiler knows the relative locations of the
components and addresses them directly.
The advantage of lists over hunks is flexibility; lists can be any length,
can vary in length, can be altered by rplacd, and can be manipulated with a
library of useful searching, sorting, and combining operations, previously
described in this chapter.
Another feature of hunks is that at times one may treat a hunk as a cons,
ignore the extra components. This allows the construction of list structure
which has extra "frobs" stuck on at certain points. The atom function does not
consider hunks to be atomic; it returns nil if given a hunk.
print represents hunks using an extended form of dot-notation; read however
does not yet understand this notation. See the writeup on print.
hunk LSUBR 0 or more args
hunk takes any number of arguments, and returns a hunk whose components are
the arguments. The first argument is the car, and the last is the cdr;
that is, the arguments are in the order 1, 2, 3, ..., N-1, 0. This is the
same order as print and makhunk use.
The maximum size of a hunk is 128 components. This may vary from
implementation to implementation.
With no arguments, hunk returns nil. With one or two arguments, hunk
returns a cons.
December 5, 1977 ∪2-3.6 Page 2-33
**DRAFT** Maclisp Reference Manual **DRAFT**
cxr SUBR 2 args
(cxr n h) returns the n'th component of the hunk h. car of a hunk returns
the 1st component, and cdr of a hunk returns the 0th component.
rplacx SUBR 3 args
(rplacx n h z) replaces the n'th component of the hunk h with z. The value
of rplacx is its (modified) second argument. rplaca of a hunk replaces its
1st component, and rplacd of a hunk replaces its 0th component.
makhunk SUBR 1 arg
(makhunk n), where n is a fixnum, creates and returns an n-element hunk,
filled with nils. (makhunk l), where l is a list, creates and returns a
hunk of the appropriate length, initialized from l. This is like (apply
'hunk l).
Like hunk, makhunk will return nil or a cons if you ask for a hunk of 0, 1,
or 2 elements.
hunksize SUBR 1 arg
hunksize returns the number of components in its argument. hunksize of nil
is 0 and hunksize of a cons is 2.
hunkp VARIABLE
If the value of hunkp is nil, the functions print, equal, and purcopy treat
hunks as conses, as most other system functions do. The extra elements are
simply ignored. If the value of hunkp is non-nil, which is the default,
these three functions deal with all the elements. sxhash always deals with
all the elements.
Page 2-34 ∪2-3.6 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
4. Flow of Control
Maclisp provides a variety of structures for flow of control.
Functional application is the basic method for construction of programs. All
operations are written as the application of a function to arguments. Maclisp
programs are often written as a large collection of small functions which
implement simple operations. Some of the functions work by calling others of
the functions, thus defining some operations in terms of others.
Recursion exists when a function calls itself. This is analogous to
mathematical induction.
Iteration is a control structure present in most languages. It is similar to
recursion but sometimes less useful and sometimes more useful. Maclisp contains
a generalized iteration facility. The iteration facility also permits those who
like "gotos" to use them.
Conditionals allow control to branch depending on the value of a predicate.
and and or are basically one-arm conditionals, while cond is a generalized
multi-armed conditional.
Nonlocal exits are similar to a return, except that the return is from
several levels of function calling rather than just one, and is determined at
run time. These are mostly used for applications such as escaping from the
middle of a function when it is discovered that the algorithm is not applicable.
Errors are a type of non-local exit used by the Lisp interpreter when it
discovers a condition that it does not like. Errors have the additional feature
of correctability, which allows a user-specified function (most often a break
loop), to get a chance to come in and correct the error or at least inspect what
was happening and determine what caused it, before the nonlocal exit occurs.
This is explained in detail on part 3.4.
Maclisp does not directly provide "hairy control structure" such as multiple
processes, backtracking, or continuations.
December 5, 1977 ∪2-4. Page 2-35
**DRAFT** Maclisp Reference Manual **DRAFT**
4.1 Conditionals
and FSUBR
(and form1 form2...) evaluates the forms one at a time, from left to right.
If any form evaluates to nil, and immediately returns nil without
evaluating the remaining forms. If all the forms evaluate non-nil, and
returns the value of the last one. and can be used both for logical
operations, where nil stands for False and t stands for True, and as a
conditional expression.
Examples:
(and x y)
(and (setq temp (assq x y))
(rplacd temp z))
(and (null (errset (something)))
(princ "There was an error."))
Note: (and) => t, which is the identity for this operation.
or FSUBR
(or form1 form2...) evaluates the forms one by one from left to right. If
a form evaluates to nil, or proceeds to evaluate the next form. If there
are no more forms, or returns nil. But if a form evaluates non-nil, or
immediately returns that value without evaluating any remaining forms. or
can be used both for logical operations, where nil stands for False and t
for True, and as a conditional expression.
Note: (or) => nil, the identity for this operation.
cond FSUBR
The cond special form consists of the word cond followed by several
clauses. Each clause consists of a predicate followed by zero or more
forms. Sometimes the predicate is called the antecedent and the forms are
called the consequents.
Page 2-36 ∪2-4.1 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
(cond (antecedent consequent consequent...)
(antecedent ...)
... )
The idea is that each clause represents a case which is selected if its
predicate is satisfied and the predicates of all preceding clauses are not
satisfied. When a case is selected, its consequent forms are evaluated.
cond processes its clauses in order from left to right. First the
predicate of the current clause is evaluated. If the result is nil, cond
advances to the next clause. Otherwise, the cdr of the clause is treated
as a list of forms, or consequents, which are evaluated in order from left
to right. After evaluating the consequents, cond returns without
inspecting any remaining clauses. The value of the cond special form is
the value of the last consequent evaluated, or the value of the antecedent
if there were no consequents in the clause. If cond runs out of clauses,
that is, if every antecedent is nil, that is, if no case is selected, the
value of the cond is nil.
Example:
(cond ((zerop x) ;First clause:
(+ y 3)) ; (zerop x) is antecedent.
; (+ y 3) is consequent.
((null y) ;A clause with 2 consequents:
(setq x 4) ; this
(cons x z)) ; and this.
(z) ;A clause with no consequents:
; the antecedent is just z.
) ;This is the end of the cond.
This is like the traditional Lisp 1.5 cond except that it is not necessary
to have exactly one consequent in each clause, and it is permissible to run
out of clauses.
December 5, 1977 ∪2-4.1 Page 2-37
**DRAFT** Maclisp Reference Manual **DRAFT**
4.2 Iteration
prog FSUBR
prog is the "program" special form. It provides temporary variables,
sequential evaluation of statements, and the ability to do "gotos." A prog
looks something like:
(prog (var1 var2...)
tag1
statement1
statement2
tag2
statement3
. . .
)
var1, var2, ... are temporary variables. When the prog is entered the
values of these variables are saved. When the prog is exited they are
restored. The variables are initialized to nil when the prog is entered,
thus they are said to be "bound to nil" by the prog. However, variables
which have been declared fixnum or flonum will be initialized to 0 or 0.0
instead, but only in compiled programs. You should be careful about
relying on the initial value of prog-variables.
The part of a prog after the temporary variable list is the body. An item
in the body may be an atomic symbol or a number, which is a tag, or a non-
atomic form, which is a statement.
prog, after binding the temporary variables, processes its body
sequentially. tags are skipped over; statements are evaluated but the
values are ignored. If the end of the body is reached, prog returns nil.
If (return x) is evaluated, prog stops processing its body and returns the
value x. If (go tag) is evaluated, prog jumps to the part of the body
labelled with the tag. The argument to go is not evaluated unless it is
non-atomic.
It should be noted that the Maclisp prog is an extension of the Lisp 1.5
prog, in that go's and return's may occur in more places than Lisp 1.5
allowed. However, the Lisp compilers implemented on ITS, Multics, and the
DECsystem 10 for Maclisp require that go's and return's be lexically within
Page 2-38 ∪2-4.2 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
the scope of the prog. This makes a function which does not contain a prog,
but which does contain a go or return uncompilable.
See also the do special form, which uses a body similar to prog. The do,
catch, and throw special forms are included in Maclisp as an attempt to
encourage goto-less programming style, which leads to more readable, more
easily maintained code. The programmer is recommended to use these
functions instead of prog wherever reasonable.
Example:
(prog (x y z) ;x, y, z are prog variables - temporaries.
(setq y (car w) z (cdr w)) ;w is a free variable.
loop
(cond ((null y) (return x))
((null z) (go err)))
rejoin
(setq x (cons (cons (car y) (car z))
x))
(setq y (cdr y)
z (cdr z))
(go loop)
err
(break are-you-sure? t)
(setq z y)
(go rejoin))
do FSUBR
The do special form provides a generalized "do loop" facility, with an
arbitrary number of "index variables" whose values are saved when the do is
entered and restored when it is left, i.e. they are bound by the do. The
index variables are used in the iteration performed by do. At the
beginning they are initialized to specified values, and then at the end of
each trip around the loop the values of the index variables are changed
according to specified rules. do allows the programmer to specify a
predicate which determines when the iteration will terminate. The value to
be returned as the result of the form may optionally be specified.
do comes in two varieties.
December 5, 1977 ∪2-4.2 Page 2-39
**DRAFT** Maclisp Reference Manual **DRAFT**
The newer variety of do looks like:
(do ((var init repeat)...)
(end-test exit-form...)
body...)
The first item in the form is a list of zero or more index variable
specifiers. Each index variable specifier is a list of the name of a
variable var, an initial value init, which defaults to nil (or possibly
zero, as mentioned under prog) if it is omitted, and a repeat value repeat.
If repeat is omitted, the var is not changed between loops.
All assignment to the index variables is done in parallel. At the
beginning of the first iteration, all the inits are evaluated, then the
vars are saved, then the vars are setq'ed to the values of the inits. To
put it another way, the vars are lambda-bound to the values of the inits.
Note that the inits are evaluated before the vars are bound. At the
beginning of each succeeding iteration those vars that have repeats get
setq'ed to the values of their respective repeats. Note that all the
repeats are evaluated before any of the vars is changed.
The second element of the do-form is a list of an end testing predicate
end-test and zero or more forms, the exit-forms. At the beginning of each
iteration, after processing of the repeats, the end-test is evaluated. If
the result is nil, execution proceeds with the body of the do. If the
result is not nil, the exit-forms are evaluated from left to right and then
do returns. The value of the do is the value of the last exit-form, or nil
if there were no exit-forms. Note that the second element of the do-form
resembles a cond clause.
If the second element of the form is nil, there is no end-test nor exit-
forms, and the body of the do is executed only once. In this type of do it
is an error to have repeats. This type of do is a "prog with initial
values."
If the second element of the form is the S-expression (nil), there is no
end-test or exit-forms, and the body of the do is executed over and over.
This is a "do forever." The infinite loop can be terminated by use of
return or throw.
The remainder of the do-form constitutes a prog-body. When the end of the
body is reached, the next iteration of the do begins. If return is used,
do returns the indicated value and no more iterations occur.
Page 2-40 ∪2-4.2 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
The older variety of do is:
(do var init repeat end-test body...)
The first time through the loop var gets the value of init; the remaining
times through the loop it gets the value of repeat, which is re-evaluated
each time. Note that init is evaluated before the value of var is saved.
After var is set, end-test is evaluated. If it is non-nil, the do finishes
and returns nil. If the end-test is nil, the body of the loop is executed.
The body is like a prog body. go may be used. If return is used, its
argument is the value of the do. If the end of the prog body is reached,
another loop begins.
Examples of the older variety of do:
(setq n (cadr (arraydims x)))
(do i 0 (1+ i) (= i n)
(store (x i) 0)) ;zeroes out the array x
(do zz x (cdr zz) (or (null zz) (zerop (f (car zz)))))
; this applies f to each element of x
; continuously until f returns zero.
Examples of the new form of do:
(do ((n (cadr (arraydims x)))
(i 0 (1+ i)))
((= i n)
(store (x i) 0))
;this is like the example above,
;except n is local to the do
(do ((x) (y) (z)) (nil) body)
is like
(prog (x y z) body)
except that when it runs off the end of the body, do loops but prog
returns nil. On the other hand,
(do ((x) (y) (z)) nil body)
is identical tk the prog above (it does not loop.)
December 5, 1977 ∪2-4.2 Page 2-41
**DRAFT** Maclisp Reference Manual **DRAFT**
(do ((x y (f x))) ((p x)) body)
is like
(do x y (f x) (p x) body)
The construction
(do ((x e (cdr x)) (oldx x x)) ((null x)) body)
exploits parallel assignment to index variables. On the first iteration,
the value of oldx is whatever value x had before the do was entered. On
succeeding iterations, oldx contains the value that x had on the previous
iteration.
In either form of do, the body may contain no forms at all. Very often an
iterative algorithm can be most clearly expressed entirely in the repeats
and exit-forms of a new-style do, and the body is empty.
(do ((x x (cdr x))
(y y (cdr y))
(z nil (cons (f x y) z))) ;exploits parallel
((or (null x) (null y)) ; assignment.
(nreverse z)) ;typical use of nreverse.
) ;no do-body required.
is like (maplist 'f x y).
go FSUBR
The (go tag) special form is used to do a "go-to" within the body of a do
or a prog. If the tag is an atom, it is not evaluated. Otherwise it is
evaluated and should yield an atom. Then go transfers control to the point
in the body labelled by a tag eq or = to the one given. (Tags may be
either atomic symbols or numbers). If there is no such tag in the body, it
is an unseen-go-tag error.
"Computed" go's should be avoided in compiled code, or altogether.
Page 2-42 ∪2-4.2 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
Example:
(prog (x y z)
(setq x some frob)
loop
do something
(and some predicate (go loop)) ;regular go
do something more
(go (cond ((minusp x) 'loop) ;"computed go"
(t 'endtag)))
endtag
(return z))
return SUBR 1 arg
return is used to return from a prog or a do. The value of return's
argument is returned by prog or do as its value. In addition, break
recognizes the typed-in S-expression (return value) specially. If this
form is typed at a break, value will be evaluated and returned as the value
of break. If not at the top level of a form typed at a break, and not
inside a prog or do, return will cause a fail-act error.
Example:
(do ((x x (cdr x))
(n 0 (* n 2)))
((null x) n)
(cond ((atom (car x))
(setq n (1+ n)))
((memq (caar x) '(sys boom bleah))
(return n))))
December 5, 1977 ∪2-4.2 Page 2-43
**DRAFT** Maclisp Reference Manual **DRAFT**
4.3 Non-local Exits
catch FSUBR
catch is the Maclisp function for doing structured non-local exits. (catch
x) evaluates x and returns its value, except that if during the evaluation
of x (throw y) should be evaluated, catch immediately returns y without
further evaluating x.
catch may also be used with a second argument, not evaluated, which is used
as a tag to distinguish between nested catches. (catch x b) will catch a
(throw y b) but not a (throw y z). throw with only one argument always
throws to the innermost catch. catch with only one argument catches any
throw. It is an error if throw is done when there is no suitable catch.
Example:
(catch (mapcar (function (lambda (x)
(cond ((minusp x)
(throw x negative))
(t (f x)) )))
y)
negative)
which returns a list of f of each element of y if y is all positive,
otherwise the first negative member of y.
The user of catch and throw is advised to stick to the 2 argument versions,
which are no less efficient, and tend to reduce the likelihood of bugs.
The one argument versions exist primarily as an easy way to fix old Lisp
programs which use errset and err for non-local exits. This latter
practice is rather confusing, because err and errset are supposed to be
used for error handling, not general program control.
The catch-tag break is used by the break function.
Page 2-44 ∪2-4.3 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
throw FSUBR
throw is used with catch as a structured non-local exit mechanism.
(throw x) evaluates x and throws the value back to the most recent catch.
(throw x tag) throws the value of x back to the most recent catch labelled
with tag or unlabelled. catch'es with tags not eq to tag are skipped over.
x is evaluated but tag is not.
See the description of catch for further details.
December 5, 1977 ∪2-4.3 Page 2-45
**DRAFT** Maclisp Reference Manual **DRAFT**
4.4 Causing and Controlling Errors
See the complete description of the Maclisp error system (part 3.4) for more
information about how these functions work.
error LSUBR 0 to 3 args
This is a function which allows user functions to signal their own errors
using the Maclisp error system.
(error) is the same as (err).
(error message) signals a simple error; no datum is printed and no user
interrupt is signalled. The error message typed out is message.
(error message datum) signals an error with message as the message to be
typed out and datum as the Lisp object to be printed in the error message.
No user interrupt is signalled.
(error message datum uint-chn) signals an error but first signals a user
interrupt on channel uint-chn, provided that there is such a channel, and
it has a non-nil service function, and the special conditions concerning
errset (see page 3-16) are satisfied. uint-chn is the name of the user-
interrupt channel to be used (an atomic symbol); see part 3.4.2. If the
service function returns an atom, error goes ahead and signals a regular
error. If the service function returns a list, error returns as its value
the car of that list. In this case it was a "correctable" error. This is
the only case in which error will return; in all other cases control is
thrown back to top level, or to the nearest enclosing errset.
errset FSUBR
The special form (errset form flag) is used to trap an expected error.
errset evaluates the form. If an error occurs during the evaluation of the
form, the error is prevented from escaping from inside the errset and
errset returns nil. If no errors occur, a list of one element, the result
of the evaluation, is returned. The result is listified so that there will
no ambiguity if it is nil. errset may also be made to return any arbitrary
value by use of the err function.
Page 2-46 ∪2-4.4 December 5, 1977
**DRAFT** Flow of Control **DRAFT**
The flag is optional. If present, it is evaluated before the form. If it
is nil, no error message will be printed if an error occurs during the
evaluation of the form. If it is not nil, or if it is omitted, any error
messages generated will be printed.
Examples:
If you are not sure x is a number:
(errset (setq x (add1 x)))
This example may not work in compiled code if the compiler chooses to open-
code the add1 rather than calling the add1 subroutine. In general, one
must be extremely foolhardy to depend on error checking in compiled code.
To suppress the error message if the value of a is not an atomic symbol:
(errset (set a b) nil)
To do the same but generate one's own message:
(or (errset (set a b) nil)
(error '(not a variable) a))
err FSUBR
(err) causes an error which is handled the same as a Lisp error except that
there is no preliminary user interrupt, and no message is typed out.
(err x) is like (err) except that if control returns to an errset, the
value of the errset will be the result of evaluating x, instead of nil.
(err x nil) is the same as (err x).
(err x t) is like (err x) except that x is not evaluated until just before
the errset returns it. That is, x is evaluated after unwinding the pdl and
restoring the bindings.
Note: some people use err and errset where catch and throw are indicated.
This is a very poor programming practice. See writeups of catch and throw
for details.
December 5, 1977 ∪2-4.4 Page 2-47
**DRAFT** Maclisp Reference Manual **DRAFT**
Page 2-48 ∪2-4.4 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
5. Atomic Symbols
5.1 The Value Cell
Each atomic symbol has associated with it a value cell, which is a piece of
storage that can refer to one Lisp object. This object is called the symbol's
value, since it is what is returned if the symbol is evaluated. The binding of
atomic symbols to values allows them to be used in programming the way
"varaables" are used in other languages.
The value cell can also be empty, in which case the symbol has no value and
is said to be unbound or undefined. This is the initial state of a newly-
created atomic symbol. Attempting to evaluate an unbound symbol causes an error
to be signalled.
An object can be placed into a symbol's value cell by lambda-binding or by
assignment. (See page 1-11.) The difference is in how closely the value-
changing is associated with control structure and in whether it is considered a
side-effect.
setq FSUBR
The setq special form is used to assign values to variables (atomic
symbols.) setq processes the elements of its form in pairs, sequentially
from left to right. The first member of each pair is a variable, the
second is a form which evaluates to a value. The form is evaluated, but
the variable is not. The value-binding of the variable is made to be the
value specified. You must not setq the special atomic-symbol constants t
and nil. The value returned by setq is the last value assigned, i.e. the
result of the evaluation of the last element of the setq-form.
Example: (setq x (+ 1 2 3) y (cons x nil))
This returns (6) and gives x a value of 6 and y a value of (6).
Note that the first assignment is completed before the second assignment is
started, resulting in the second use of x getting the value assigned in the
first pair of the setq.
December 5, 1977 ∪2-5. Page 2-49
**DRAFT** Maclisp Reference Manual **DRAFT**
set SUBR 2 args
set is like setq except that the first argument is evaluated; also set only
takes one pair of arguments. The first argument must evaluate to an atomic
symbol, whose value is changed to the value of the second argument. set
returns the value of its second argument. Example:
(set (cond ((predicate) 'atom1) (t 'atom2))
'stba)
evaluates to stba and gives either atom1 or atom2 a value of stba.
set could have been defined by:
(defun set (x y)
(eval (list 'setq x (list 'quote y))))
Alternatively, setq could have been defined by:
(defun setq fexpr (x)
((lambda (var val rest)
(set var val)
(cond ((null rest) val)
((apply (function setq) rest)) )) ;if more, recurse
(car x)
(eval (cadr x))
(cddr x)))
symeval SUBR 1 arg
(symeval a) returns the value of a, which must be an atomic symbol. The
compiler produces highly optimal code for symeval, making it much better
than eval when the value of a symbol needs to be taken and the particular
symbol to be used varies.
Page 2-50 ∪2-5.1 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
boundp SUBR 1 arg
The argument to boundp must be an atomic symbol. If it has a value, t is
returned. Otherwise nil is returned.
makunbound SUBR 1 arg
The argument to makunbound must be an atomic symbol. Its value is removed,
i.e. it becomes unbound.
Example:
(setq a 1)
a => 1
(makunbound 'a)
a => unbnd-vrbl error.
makunbound returns its argument.
December 5, 1977 ∪2-5.1 Page 2-51
**DRAFT** Maclisp Reference Manual **DRAFT**
5.2 The Property List
A property-list is a list with an even number of elements. Each pair of
elements constitutes a property; the first element is called the "indicator" and
the second is called the "value" or, loosely, the "property." The indicator is
generally an atomic symbol which serves as the name of the property. The value
is any Lisp object.
For example, one type of functional property uses the atom expr as its
indicator. In the case of an expr-property, the value is a list beginning with
lambda.
An example of a property list with two properties on it is:
(expr (lambda (x) (plus 14 x)) foobar t)
The first property has indicator expr and value (lambda (x) (plus 14 x)), the
second property has indicator foobar and value t.
Each atomic symbol has associated with it a property-list, which can be
retrieved with the plist function. It is also possible to have "disembodied"
property lists which are not associated with any symbol. These keep the
property list on their cdr, so the form of a disembodied property list is
(<anything> . plist). The way to create a disembodied property list is (ncons
nil). Atomic symbols also (usually) keep their property list on their cdr, but
you aren't allowed to know that. Use the plist function to get the property
list of a symbol.
Property lists are useful for associating "attributes" with symbols. Maclisp
uses properties to remember function definitions. The compiler uses properties
internally to keep track of some of what it knows about the program it is
compiling.
The user familiar with Lisp 1.5 will want to note that the property list
"flags" which are allowed on Lisp 1.5 property lists do not exist in Maclisp.
However, the same effect can be achieved by using properties with a value of t
or nil.
Some property names are used internally by Maclisp, and should therefore be
avoided in user code. These include args, array, autoload, expr, fexpr, fsubr,
lsubr, macro, pname, sublis, subr, value, used by the Lisp system proper; arith,
Page 2-52 ∪2-5.2 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
*array, atomindex, *expr, *fexpr, *lexpr, numfun, number, numvar, ohome,
special, sym, used by the compiler; grindfn, grindmacro, used by the grinder.
get SUBR 2 args
(get x y) gets x's y-property. x can be an atomic symbol or a disembodied
property list. The value of x's y-property is returned, unless x has no y-
property in which case nil is returned. It is not an error for x to be a
number, but nil will always be returned since numbers do not have property
lists.
Example:
(get 'foo 'bar)
=> nil ;initially foo has no bar property
(putprop 'foo 'zoo 'bar) ;give foo a bar property
=> zoo
(get 'foo 'bar) ;retrieve that property
=> zoo
(plist 'foo) ;look at foo's property list
=> (bar zoo ...other properties...)
get could have been defined by:
(defun get (x y)
(do ((z (cond ((numberp x) nil)
((atom x) (plist x))
(t (cdr x)))
(cddr z)))
((or (null z) (eq y (car z)))
(cadr z))))
This relies on the fact that the car and the cdr of nil are nil, and
therefore (cadr z) is nil if z is nil.
getl SUBR 2 args
(getl x y) is like get except that y is a list of indicators rather than
just a single indicator. getl searches x's property list until a property
whose indicator appears in the list y is found.
December 5, 1977 ∪2-5.2 Page 2-53
**DRAFT** Maclisp Reference Manual **DRAFT**
The portion of x's property list beginning with the first such property is
returned. The car of this is the indicator (property name) and the cadr is
the property value. getl returns nil if none of the indicators in y appear
on the property list of x. getl could have been defined by:
(defun getl (x pl)
(do ((q (plist x) (cddr q))) ; scan down P-list of x
((or (null q) (memq (car q) pl))
q)))
This definition is simplified and doesn't take numbers and disembodied
property lists into account.
putprop SUBR 3 args
(putprop x y z) gives x a z-property of y and returns y. x may be an
atomic symbol or a disembodied property list. After somebody does (putprop
x y z), (get x z) will return y.
Example:
(putprop 'Nixon 'not 'crook)
If the symbol already has a property with the same name that property is
removed first. This ensures that getl will always find the property which
was put on most recently. Fop instance, if you were to redefine an expr as
a subr, and theN redefine it as an expr again, this effect of putprop
causeq the evaluator to find the l@¬iKgh↓IKMS9SiS←8ACYO¬sfL~(~∀@@@AαA1Sg`A⊃KMS]%iS←\↓←LAi!JAECMSFAaUiae←@AoSi!←khAβ##∃β≤¬voεM≤6∂&≥⎇g~ε|dεw.\,Wπ_Q$ααα∧λ⊗v" M↔∞∞\-v&N\@ππ⊗}λW.≡(⊂⊗~yz9P≠tst:λ12]εBεA⊂⊂λ⊂⊂⊂⊂λ∀22c≥w⊂8:]897xλ∀8⊂<H=∀FEλ⊂⊂⊂⊂λ⊂⊂⊂⊂
92vx≤7x⊂,λ=∀FEλ⊂⊂⊂⊂λ⊂⊂⊂⊂
9rz8≠4yz≡⊂⊂1`/ns z (cons y (plist x))))
q)
¬
Page 2-∃4 ∪2-5.2 DecEmber 5, 1977
**DRAFT** Atomic Sqmbols **DRAFT
*
defprop FSUBR
defProp is a version of putprop with no argument-evaluation, which is
sometimes more convenient for typing∞ For instance,
(defprop foo bar oftenwith)
is equivalent to
(putprop 'foo 'bar 'oftenwith)
remprop SUBR 2 args
(remprop x y) removes x's y-property, by splicing it out of x's property
list. The value is nil if x had no y-property. If x did have a y-
property, the value is a list whose car is the property, and whose cdr is
part of x's property list, similar to (cdr (getl x '(y))).
x may be an atomic symbol or a disembodied property list. Example:
(remprop 'foo 'expr)
undefines the function foo, assuming it was defined by
(defun foo (x) ... )
plist SUBR 1 arg
(plist x) returns the property list of the atomic symbol x.
setplist SUBR 2 args
(setplist x l) sets the property list of the atomic symbol x to l. This is
to be used with caution, since in some implementations property lists
contain internal system properties which are essential to the workings of
the Lisp system.
December 5, 1977 ∪2-5.2 Page 2-55
**DRAFT** Maclisp Reference Manual **DRAFT**
5.3 The Print-Name
Each atomic symbol has an associated character string called its "print-
name," or "pname" for short. This character string is used as the external
representation of the symbol. If the string is typed in, it is read as a
reference to the symbol. If the symbol is to be print'ed, the string is typed
out.
See also page 2-83 for some other functions which have to do with pnames.
samePnamep SUBR 2 args
The arguments to samepnamep must evaluate to atomic symbols or to character
strings. The result is t if they have the same pname, nil otherwise. The
pname of a character string is considered to be the string itself.
Examples:
(samepnamep 'xyz (maknam '(x y z)))
(samepnamep 'xyz (maknam '(w x y))) => nil
(samepnamep 'x "x") => t
alphalessp SUBR 2 args
(alphalessp x y), where x and y evaluate to atomic symbols or character
strings, returns t if the pname of x occurs earlier in alphabetical order
than the pname of y. The pname of a character string is considered to be
the string itself. Examples:
(alphalessp 'x 'x1) => t
(alphalessp 'z 'q) => nil
(alphalessp "x" 'y) => t
Note that the "alphabetical order" used by alphalessp is actually the ASCII
collating sequence. Consequently all upper case letters come before all
lower case letters.
Page 2-56 ∪2-5.3 DecEmber 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
pnget SUBR 2 args
(pnget symbol n) returns the pname of the symbol as a list of fixnums
containing packed n-bit bytes. The legal values of n depend on the
implementation; in the pdp-10 implementation, 6 (SIXBIT) and 7 (ASCII) are
allowed. If this seems obscure, that's because it is. Example:
(pnget 'MUMBLERATOR 7) =>
(-311246236550 -351327625542 -270←33)
pnput SUBR 2 args
This is a sort of inverse of pnget. (pnput (pnget foo 7) flag) returns a
symbol with the same pname as foo. The symbol is interned if flag is non-
nil.
December 5, 1977 ∪2-5.3 Page 2-57
**DRAFT** Maclisp Reference Manual **DRAFT**
5.4 Interning of Symbols
One normally wants to refer to the same (eq) atomic symbol every time the
same pname is typed. Maclisp implements this through what is called the
obarray. The obarray is a hash-table of atomic symbols. These symbols are said
to be interned, or registered in the obarray. Whenever a pname is read in Lisp
input, the obarray is searched for a symbol with the same pname. If one is
found, the pname is considered to refer to that symbol. If not, a new symbol is
created and added to the obarray.
The representation of an obarray is a Lisp array. The first 510. (or
thereabouts) elements of the array contain lists which are buckets of a hash
table. The last 128. elements of the array contain the "character objects,"
symbols with 1-character pnames. (These entries contain nil if the
corresponding symbol has not yet been interned.) The character objects are
treated specially for efficiency. There are usually one or two unused array
elements between these two areas.
In order to allow for multiple name spaces, Maclisp allows multiple obarrays.
An obarray can be made "current" by binding the symbol obarray to the
appropriate array-pointer. See page 2-89 for details on how to manipulate
obarrays and arrays in general.
It is possible to have a symbol interned on several obarrays at the same
time. It is also possible to have two different (non-eq) symbols with the same
pname interned on different obarrays. Furthermore it is possible to have a
symbol which is not interned on any obarray, which is called an uninterned
symbol. These are useful for purely-internal functions, but can cause
difficulty in debugging since they can't be accessed directly. Such a symbol
can be accessed via some data structure that contains it, set up by the program
that created it.
Normally symbols are never removed from obarrays. It is possible for the
user to explicitly remove a symbol from the current obarray. There is also a
feature by which "truly worthless" symbols may be removed automatically (see
page 3-58).
Page 2-58 ∪2-5.4 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
intern SUBR 1 arg
(intern x), where x is an atomic symbol, returns the unique atomic symbol
which is "interned on the obarray" and has the same pname as x. If no
symbol on the current obarray has the same pname as x, then intern will
place x itself on the obarray, and return it as the value.
remob SUBR 1 arg
The argument to remob must be an atomic symbol. It is removed from the
cuRpent obarray i@_AShAαK@~α
→g&/-lV"ε⎇dπ&F≤@λ
|X<\L∨+Hλ
M~<h
\:y0→H⊂:42H0z7vZqFE⊂λ⊂⊂⊂9↑vq7fλ4s0qXryydX42P:≠P0w<H)Vrl≤92yyZww9Pλ:40zλ6p|P_2P92Xp∧ iN kr lh∂CI∃HAS\4∀@@@AiQJ↓Ici@,ε&*R∧λ L]9x@∞ =→0→≠9P74[↔αEεB∧¬∃Gα{CgOL¬V⊗↑D∧ααα∧∧αααλ:T¬∩∧ λ ≡Yx FB∧@
A↓`∂W ⊂∧αε@yH⊂~≥wP0y→βuee@9ifL@A)QJ↓H 'K≤εBαε≤,w.n]nBε@=<u∧ Y(λ ∀≤}3,-{ λ∧ 8π2 the
q` G←αs⊃βOF{W3⊃∧∧&*πD∧ε␈∩
m⊗br∧
FF*∞,W>9_
is @∧AUKn0A`↔m_ NL<[Y,Dλ≤v-\Y{ ∧∞z=~↓QHλλ∧∧≥~→$∞x;9$∞≠X;,T_8 P≥42P \3zvr[8∪⊂⊂λ*w4`.terned" means @QQChAβ##∃β≥K7 ∨bβ#πM∧s?P4R↓↓↓↓∧∪↔πd
εf∞<X ∧
{H⊂-o(λ⊂↔X0y0∩ay( @A%H βSF)βO↔≤¬vv"∧λ↔⊗?]\Vw"
_ d∞ λ⊂~~2P⊂'→{P9l[q3vεB⊂⊂⊂⊂λ;tv&λ12P#Z{2w the pπCKJ↓mC@3.)βπM∧εFF*
x M≤z;X-Dλ_;LD≥z3
D~_=LT_(⊂⊃[x8 ob i@Q` 4)α↓↓↓β¬∪?C↔↔#e↓βd¬↔> Hλ∧
~≥<d∞~→(∧
Y=h∧∞z;∪∧∞⎇_<NDλ≠⎇.Dλ≥z.Mλ≥~ Tλ≤p-\αP⊂+_v:rP_w2εEλ⊂⊂⊂⊂≤97p2\αpieS as The Old$ @ khAS_@ASh↓SfAg∃ibOK⊂@A←d↓aci@¬∪?A∨.!1βSF)↓β[∞cW*
x AQHλλ∧∧≤≤[n <Y≡$
yH∃
(≠p⊗→⊂⊂;t[4∧ not be changed. If The secondarguMent is nil,
Tsibly internal
system properties.)
gensym LSUBR 0 or 1 args
gensym creates and returns a new atomic symbol, which is not interned on an
obarray (and therefore is not recognized by read.) The atomic symbol's
pname is of the form prefix number, e.g. g0001. The number is incremented
each time.
If gensym is given an argument, a numeric argument is used to set the
number. The pname of an atomic-symbol argument is used to set the prefix.
For example:
December 5, 1977 ∪2-5.4 Page 2-59
**DRAFT** Maclisp Reference Manual **DRAFT**
if (gensym) => g0007
then (gensym 'foo) => f0008
(gensym 40) => f0032
and (gensym) => f0033
Note that the number is in decimal and always four digits, and the prefix
is always one character.
Page 2-60 ∪2-5.4 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
5.5 Defining Atomic Symbols as Functions
Atomic symbols may be used as names for functions. This is done by putting
the actual function (a subr-object or a lambda-expression) on the property list
of the atomic symbol as a "functional property," i.e. under one of the
indicators expr, fexpr, macro, subr, lsubr, or fsubr.
Array properties (see page 2-89) are also considered to be functional
properties, so an atomic symbol which is the name of an array is also the name
of a function, the accessing function of that array.
When an atomic symbol which is the name of a function is applied, the
function which it names is substituted.
defun FSUBR
defun is used for defining functions. The general form is:
(defun name type (lambda-variable...)
body...)
However, name and type may be interchanged. type, which is optional, may
be expr, fexpr, or macro. If it is omitted, expr is assumed. Examples:
(defun addone (x) (1+ x)) ;defines an expr
(defun quot fexpr (x) (car x)) ;defines a fexpr
(defun fexpr quot (x) (car x)) ;is the same
(defun zzz expr x ;this is how you
(foo (arg 1)(arg 2))) ; define a lexpr.
The first example above is really just defining a synonym. Another way to
do this is:
(defprop addone 1+ expr)
That is, an atomic functional property indicates synonyming. This can be
particularly useful to define a macro by an expr or fexpr, or even by a
subr.
December 5, 1977 ∪2-5.5 Page 2-61
**DRAFT** Maclisp Reference Manual **DRAFT**
The functions defProp and putprop may also be used for defining functions.
There is a feature by which, when a file of functions has been compiled and
loaded into the lisp environment, the file may be edited and then only
those functions which were changed may be loaded for interpretive
execution. This is done by compiling with the "E" switch, and then reading
in the source file with the variable defun bound non-nil. Each function
will have an expr-hash property maintained, which contains the sxhash of
the interpreted definition od the function. defun will only redefine the
function if this hash-code has changed. This feature is rather dangerous
since reasonable alterations tk the function defInition may not change the
sxhash and consequently may not take effect. BecauSe of its general
losingness, this feature is only available in the pdp-10 implementation and
sometimes not even there.
defun could have been defined by:
(defun defun fexpr (x) ;circular, but you get the idea
(prog (name type body)
; first, analyze the form, get arguments.
(cond ((memq (car x) '(expr fexpr macro))
(setq type (car x)
name (cadr x)
body (cddr x)))
((memq (ca`r x) '(expr fexpr macro))
(setq name (car X)
type (cadr x)
body (cddr x)))
((setq name (car x)
type 'expr
body (cdr x))))
(setq body (cons 'laebda body))
Page 2-62 ∪2-5.5 December 5, 1977
**DRAFT** Atomic Symbols **DRAFT**
; now, check for expr-hash hair.
(cond ((and defun
(get name 'expr-hash)
(= (get name 'expr-hash)
(sxhash body)))
)
; actually make the definition.
((putprop name body type)))
(return name)))
args LSUBR 1 or 2 args
(args f) tells you the number of arguments expected by the function f. If
f wants n arguments, args returns (nil . n). If f can take from m to n
arguments, args returns (m . n). If f is an fsubr or a lexpr, expr, or
fexpr, the results are meaningless.
(args f x), where x is (nil . n) or (m . n), sets the number of arguments
desired by the function f. This only works for compiled, non-system
functions.
sysp SUBR 1 arg
The sysp predicate takes an atomic symbol as an argument. If the atomic
symbol is the name of a system function (and has not been redefined), sysp
returns the type of function (subr, lsubr, or fsubr). Otherwise sysp
returns nil. Examples:
(sysp 'foo) => nil (presumably)
(sysp 'car) => subr
(sysp 'cond) => fsubr
December 5, 1977 ∪2-5.5 Page 2-63
**DRAFT** Maclisp Reference Manual **DRAFT**
Page 2-64 ∪2-5.5 December 5, 1977
**DRAFT** Numbers **DRAFT
*
6. Numbers
FOp a description of the various typeq of numbers used in Maclisp, see part 1.2.
6.1 Number Predicates
zerop SUBR 1 arg
¬
The zerkp predicate retuRns t if its argument is fiXnum zero or fLonum
zero. (There is no bignumzero.) Otherwisa it returns nal. It is an
errkr id the argumeft is not a Number,∧@A∪_AiQCPASfAA←ggS YJAg%O]`AMQ←kY⊂AEJ~(@@@@↓kgKH8~∀
∀4∃aYkM`@@@@@@@@@@@A'+¬H@bACIN~∀~(@@@@↓)QJAAYcg`AaeK⊃SGCi∀AeKiUe]f@↓hASLASif↓CeOk5K]h@↓SfAgQ` '∂&ce↓β?∪↔πS/⊃βS#∞p4)↓α↓↓βk/∪=1βvK1β'2β'QβO→βk↔⊗yβ?I∧s↔∨π&K[∃9αα'QβO→βπ9ε+@↔⊗}$εN2∞Mε*ε≡,w.n]nBεO4
f␈ Q$ααα∧ ∩εw]\&/∩aQ hPQ)VNw↑>ααα∧∧ααα∧∧ααα∧
5,∃$ε∩ε∂,qPPh$∧ααα
Mε*ε]≥g/∨∧∞π⊗.M≤6∂&T∞&/'↑-g~πD
⊗2ε≡N2ε∂,}Vn.nDεO~ ∀εv.|≡FO6T
g.n,↑"bεm≥BεNaQ"αα∧∧εO"
≡2αε∀ f}r]lV>∂M≡f*α
nVn⊗↑%bα∧≡DαεO4 ⊗rε↑.&␈∩∧
⊗"πM Rαε≡,w.n]nBεO4∧εv␈D ⊂hR∧∧ααεn]V⊗/%aPPh!Q&}&N∧ααα∧∧ααα∧∧ααα∧∧¬≥,*$β
ε≡,phPQ$ααα∧
FF*
xF'α∞∞&.&≤<↔&*∧∞&/'↑-g~πD
⊗2ε≡N2αε≡,w.n]nBεO4 ⊗rε|LBαεn]V⊗/%Dε␈& ↑'>O<QPRα∧∧αεv≥Ebα¬M Rε∂,}Vn.nDεo/>Dε⊗* ∀ε&O
nVjε}$ε
ε-≤vw.UaPPh!Q hPQ!PPh!Q hTL\6.n,↑"β*Dε∪K;t∧ααα∧∧ααα∧∧ααα∧∧ααα∧α3∩kedααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα
⊗>*ε%S3(Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hW=≤vwα∧∧ααα∧∧ααα∧∧αα∧j:T∃⊂Q!PRα∧∧α¬& Tπ≡N⎇nααπ∞,V&N<≡F*ε≡4π/≡\Dαπ&t∞F/∨D∞FF*∧∞6N>d
v2ε∀∧εw.\,W∩r∧¬π≡N⎇nααε4∂αHh$∧ααα∞,W'/-n2π"∧
⊗2π∧}2απ=≤vrπ<≡FO≡m≤W~πM RαπL↑7"ε5Dαεv≥DεN2
≡BαεM|W~εm}Brα∧∂αεO1Q"αα∧∧ε/6≥NV∂&\Dε↔/D 2εO4
f␈"d∧¬&FT∞&/∨]NBεO4 ⊗g>∨≡2εv≥DεN2∂∧εO~
mw"ε∀∧εw.\,W∩r∧ 0hR∧∧ααε<≥bε⊗T
vv*
|bπ& Tε6}MMw>Nlw hPQ$ααα∧∧ααα∧∧ααα∧∧ααεD∧ααα∧∧εn.≥n2αα∧∂βcQ$ααα∧∧ααα∧∧ααα∧∧ααεLTααα∧∧ααα$∧ααα∧∂β`Ev↓PRα∧∧ααα∧∧ααα∧∧ααα∧ Rαα∧∧ααα∧∧"αα∧∧απCV↓PRα∧∧ααα∧∧ααα∧∧ααα∧
bαα∧∧ααα∧∧"αα∧∧απCQ¬sh$∧ααα∧∧ααα∧∧ααα∧∧αε>T∧ααα∧∧αα∩∧∧ααα∂π`E{↓Q"αα∧∧ααα∧∧ααα∧∧ααα tααα∧∧ααα∧$ααα∧∧πCs↓Q hR∧∧αα∧← ⊗oεL↑3Ph$∧ααα∧∧ααα∞=⊗>w∧
F*αV∃∩βkd∞@hR∧∧ααα∧∧ααG=≤vwα
dβαJπWbεv≥APRα∧∧ααα∧∧αG≡≤⎇gαεt∧rF6⎇tαrε,≡"JJπWbεv≥APPh!Q&F∂]Mvv:∧∧ααα∧∧ααα∧∧¬≥,*$β
ε≡,phPQ$ααα∧¬εF∂]Mvv:∂¬∩π⊗↑NW⊗w4∞FF*
nVn⊗↑$ε}2∞=⊗>v≤m⊗≡∞nDε⊗ON4εNr∂¬bαπ∧ 6∞r ,Rε
m↔Fw]QPRα∧∧αε␈$ ∩αε-≤vw.Udα¬& Tπ⊗/>]G"α
≡2π& Tαεf\≡7"ε≥nF.>↑$εv␈D∧εf/>4π&F≥dαπ& Tε⊗∂<US⊂h$∧ααα
Mv>∂-≡FFj
|bπg∂E3
pQ!PRα∧∧ααα∧λWF∞↑
F/≠!Q"αα∧∧ααα∧∧ααα
↔.f⎇lrβα∀πSrβ↓Q"αα∧∧ααα∧∧ααα
↔.f⎇lrβ~∀πSrβ!Q"αα∧∧ααα∧∧ααα
↔.f⎇lrαku∀βkrε1PRα∧∧ααα∧∧ααα¬
ε∂.M⎇f:β⊗&3#+fv∪∪≠FVc:JπWbβ#¬aPPh!Q hPQ!PPh!Q hPQ!PPh!Q hU ≤v*β%Vc2α∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧α3∩kef∩αα∧∧ααα∧∧ααα∧∧ααα∧∧α∧&\<Vn⊗↑$β*bε↔∪;8Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αα∧n]V⊗/.4ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hSef"α∧=⎇Wε∂-≡6}pQ!PPh'Tααα∧∧ααα∧∧ααα∧∧ααα
:T∃∩ε$ε∂⊗}1PPh$∧ααα¬πRπB∧∂∩Jε≡4απ"
≤bπB∧ ⊗v"∂∀αε∂,Tεw.\↑&N≡≥MGJε↑≡V∞bd∧απB ≥f"α∂∀εo/>Dαε⊗T &␈&↓Q"αα∧∧ε6O
nVo~
}"ε⊗}Mαε6M⎇g.o5dα¬/<Tε/∂\≥Bπ&t 6}o ≡&*ε-≤vw.↑5`hPQ!PV?,\↔&/.∧ααα∧∧ααα∧∧α∧e:X%∩β$
w∩ε]}&*ε≡,w_h!Q"αα∧∧ε?⊗\≡F/↔∧ 6}o ≡&/~
≡G~ε≡,w.n]nG~b∞⎇εN≡∧
W/∨D &*εn]V⊗/.5Bε7-⎇Rεf\nBπ&t∞&N>∞E`hR∧∧αα∧≤dε∞w∀ ↔⊗?]\Vw"
≡2εv}Dε?⊗\≡F/∩∞Mε∞r∞Mε*εl←π"b }&.∂L↑'απ,↑G/⊗n4εvNEdα∧↔↑DεN0Q$ααα∧∞FF*∧ ↔⊗?]\Vw'4∧π&z∧ w⊗.≡LW↔α∧ ↔⊗*∞>G⊗N>MGJα LV∨⊗\≡6NvuDαπ& Tαπ⊗↑>Vg"∧
↔~πEaPRα∧∧α∧/ ≥Wεf↑7 hPQ$ααα∧∧ααα∧∧ααα∧∧αF?,\↔&/.∧β"β5∀βkr∞APRα∧∧ααα∧∧ααα∧∧ααα }&.∂L↑'αβ∀ε∩JβWdεvNAQ"αα∧∧ααα∧∧ααα∧∧ααF},V∂&↑.αβ"f∧β~sd¬S∩JπWbπ Q$ααα∧∧ααα∧∧ααα∧∧αF?,\↔&/.∧β"β4ε∩β∩ε¬∩βkd
fN`Q!PPh'dααα∧∧ααα∧∧ααα∧∧ααα
:T∃∩ε$ε∂⊗}1PPh$∧ααα¬πbπB∂∃∩εO4∞BεNd∂αεO4∧π∨'-≤7&g∀ w⊗.≡LW∩πM ⊗rπ∃Dε∞vD
fNb
}FF/.⎇↔≡*d∧πBα ≥f"π⊃Q"αα∧∧εo/>Dε⊗* -w&B m↔Fw]↑2ε␈$ &␈&∧ ff}n]W~pQ!PPh-LW∨∨∧∧ααα∧∧ααα∧∧ααα J5,∃$ε"ε␈$
V␈⊗T ↔⊗?1Q hR∧∧ααεL↑7∨α =voε≡,W~ε≡N2αε≡,w.n]nG~b∞⎇εN≡∧
W/∨D &*α
nVn⊗↑.2bεn-vjεL\g"α∞Mrπ⊗≤⎇π"pQ$ααα∧ ⊗2ε≥o∩ε∂,}Vn.nDεO~
mw"εL↑7~α∞Mε∞r∞Mε*εl←π"b
LW∨∨∧∞&/'↑-g~εm≥Brαλ.W"α
≤bπ& QPRα∧∧αε∂,}Vn.nN2π&t
F/∨>∧ε∂⊗T∞7'⊗≤>FgJ
≥f∨⊗\≡6NvuDπ&FT∞&/∨]NBεO4∞Brαλ←ε∞o
LW≠PQ!PRα∧∧ααα∧∧ααα∧∧ααα
LW∨∨∧ε2β"∀πSrπAQ"αα∧∧ααα∧∧ααα∧∧ααFL↑7∨αε∀β
JπWbεv≥APRα∧∧ααα∧∧ααα∧∧ααα
LW∨∨∧¬S∩β5fbβ"∀πSrπAQ"αα∧∧ααα∧∧ααα∧∧ααFL↑7∨αε∧β∩β∀ε2β"∀πSrεm≥@hPQ!PPh!Q hPQ(F.≡]\&/∩εUBβ ⊗vrαα∧∧ααα∧∧ααα∧∧ααα∧∧α↓≠%Vbs∩∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧¬ε∞|Tβ∩kfqPP **DRAFT** Maclisp Reference Manual **DRAFT**
< SUBR 2 args
(< x y) is t if x is strictly less than y, and nil otherwise. x and y must
be both fixnums or both flonums.
max LSUBR 1 or more args
max returns the largest of its arguments, which must be numbers. If any
argument is a flonum, the result will be a flonum. Otherwise, it Will be a
fixnum or a bignum depending on its magnitude.
min LSUBR 1 or more args
min returns the smallest of its arguments, which must be numbers. If any
argument is a flonum, the result will be a flonum. Otherwise, it will be a
fixnum or a bignum depending on its magnitude.
Page 2-68 ∪2-6.2 December 5, 1977
**DRAFT** Numbers **DRAFT**
6.3 Conversion
fix SUBR 1 arg
(fix x) converts x to a fixnum or a bignum depending on its magnitude.
Examples:
(fix 7.3) => 7
(fix -1.2) => -2
(fix 104) => 104
ifix SUBR 1 arg
(ifix x) converts x from a flonum to a fixnum. ifix will never return a
bignum, unlike fix. This allows it to be efficiently open-coded. This is
not the same function as IFIX in Fortran; rounding is down rather than
towards zero. It is like ENTIER in Algol.
ifix does not exist in the Multics implementation.
float SUBR 1 arg
(float x) converts x to a flonum. Example:
(float 4) => 4.0
(float 3.27) => 3.27
abs SUBR 1 arg
(abs x) => |x|, the absolute value of the number x. abs could have been
defined by:
(defun abs (x) (cond ((minusp x) (minus x))
(t x) ))
December 5, 1977 ∪2-6.3 Page 2-69
**DRAFT** Maclisp Reference Manual **DRAFT**
minus SUBR 1 arg
minus returns the negative of its argument, which can be any kind of
number. Examples:
(minus 1) => -1
(minus -3.6) => 3.6
haipart SUBR 2 args
(haipart x n) extracts n leading or trailing bits from the internal
representation of x. x may be a fixnum or a bignum. n must be a fixnum.
The value is returned as a fixnum or a bignum. If n is positive, the
result contains the n high-order significant bits of |x|. If n is
negative, the result contains the |n| low-order bits of |x|. If |n| is
bigger than the number of significant bits in x, |x| is returned.
Examples:
(haipart 34567 7) => 162
(haipart 34567 -5) => 27
(haipart -34567 -5) => 27
Page 2-70 ∪2-6.3 December 5, 1977
**DRAFT** Numbers **DRAFT**
6.4 Arithmetic
General Arithmetic
These functions will perform arithmetic on any kind of numbers, and always
yield An exact result, except when used with flonums. (Flonums have limited
precision and range.) Conversions to flonum or bignum representation are done as
needed. Flonum representation will be used if any of the arguments are flonums;
otherwise fixnum representation will be used if the result can fit in fixnum
form, or bignum representation if it cannot.
The two sections after this one describe other Arithmetic fqnctions which are
more efficient but less powerful.
plus LSUBR 0 or more args
plus returfs the sum of its arguments, which may be any kind of numbers.
differenc@∀@@@@@@@@↓→'+¬H@bA←HA[←e∀ACeOL~∀
∀@@@A⊃SMMKIK]GJ↓eKikI]fASQfAMSIghACIOk[K9hA[S9kfAi!JAeKMhA←L↓Sif@↓CeOk5K]if8@A∪h4∀@@@Ao←e-fAM←HAC]r↓WS]H↓←LA]U[EKeL\~∀~(~∃iS5Kf@@@@@@@@@@@A→'U¬$@`↓←dA[=eJACIOf~∀4∀@@@AiS[∃f@Ae∃ice]LAiQJAae←⊃kGhA=L@ASQfACe≥k[K]QfT@@↓∪hAo=eWf@↓M←dA¬]r@A-S]HA=L~∀@@@A]U[EKeL\~∀~(~∃ck=iSK]P@@@@@@@@@A→'U¬$@b↓←dA[=eJACIOf~∀4∀@@@Ack←QSK]h↓aKikβ∪;MβO#Eβ≠O∪OQβ∂∪↔W7,sQ↓β&K['∪.!β eπ##∃β⊗+OQβ|1↓β''→βπK?+7↔nN2ph$∧ααα
Mε*ε≤,w.n]nG
ε\∨∩ε∞o∀ε↑Nl@ε}2
nVn⊗↑%`hPQ$ααα∧∧αα∧← ⊗oεL↑3Ph$∧ααα∧∧ααα¬∞↔.␈M_Vw"ε4β∩J∧πSrβ∀∧ααα∧π6&O
nVjεM~fO≡≥ybπ',Yf≡∂L↑2`h!Q"αα∧∧ααα∧∧αG∂]x
≤;]ε4 K@_
P≡←⊂λ_W~Pλ≥q2`4 fdonum divisi@=\AI←∃`
β;|εB`! C"AQHλλ∧∧λλλ∧∧λ≤=-}~90↔≥⊂≠↔λλ_W~Pλ→↔_∀H≤[⊂→ _εEεB ∧ec@∃[EKdα↓U "∧∪∪+hλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ∧lEVKM⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂(0sYP→⊗@71
α **DRAFT** MacliSp Re@→KeK]
JA7∞sWπD∧ααα∧∧ααα∧∧ααα∧∧ααααJQ
(1Q∃
∧¬α
add1 S@+ $@bAα C≤4Ph ∩α∧∧ααF≤LC
πα
(πWH≡αf∃β⊂⊂ 8 h Cr↓EJAC9rAWSαs⊃β?2β;G\,W%C"C!arg
(sub1 x) => x-1. x may be any kind of number.
remainder SUBR 2 args
(remainder x y) => the remainder of the division of x by y. The sign of
the remainder is the same as the sign of the dividend. The arguments must
be fixnums or bignums.
gcd SUBR 2 args
(gcd x y) => the greatest common divisor of x and y. The arguments must be
fixnums or bignums.
expt SUBR 2 args
z
(expt x z) = x
The exponent z may be a bignum if the base x is 0, 1, or -1; otherwise z
should be a fixnum. x may be any kind of number.
As a special feature, expt allows its second argument to be a flonum, in
which case the first argument is converted to a flonum and the
exponentiation is performed in floating point, using logarithms. The
result is a flonum in this case.
*dif SUBR 2 args
*dif is a subr form of difference. It is documented here because some
people use it. There is no reason to use it, since the compiler
automatically converts difference into *dif as required.
Page 2-72 ∪2-6.4 December 5, 1977
**DRAFT** Numbers **DRAFT**
*quo SUBR 2 args
*quo is a subr form of quotient. It is documented here because some people
use it. There is no reason to use it, since the compiler automatically
converts quotient into *quo as required.
December 5, 1977 ∪2-6.4 Page 2-73
**DRAFT** Maclisp Reference Manual **DRAFT**
Fixnum Arithmetic
These functions require their arguments to be fixnums and produce only fixnum
results. If the true result, which would be returned by the more general
functions described previouslY, is too large tk be represented as a fixnum, the
result actually returned will be truncated to an implementation-dependent number
of bits, which is 36. (including the sign) in the Multics and pdp-10
implementations. The compiler produces highly-optimized code for these
operations.
+ LSUBR 0 or more args
+ returns the sum of its arguments. The arguments must be fixnums, and the
result is always a fixnum. Examples:
(+ 2 6 -1) => 7
(+ 3) => 3 ;trivial case
(+) => 0 ;identity element
- LSUBR 0 or more args
This is the fixnum-only subtraction function. With one argument, it
returns the number's negation. With more than one argument, it returns the
first argument minus the rest of the arguments.
(-) => 0, the identity element
(- 3) => -3
(- 5 3) => 2
(- 2 6 -1) => -3
etc.
* LSUBR 0 or more args
* returns the product of its arguments. Examples:
(* 4 5 -6) => -120.
(* 3) => 3 ;trivial case
(*) => 1 ;identity element
Page 2-74 ∪2-6.4 December 5, 1977
**DRAFT** Numbers **DRAFT**
/ LSUBR 0 or more args
This is the fixnum-only division function. The arguments must be fixnums
and the result of the diviSion iq truncated to an integer and returned as a
fixnum* Note that The name oF this function must be typed in as //, sifce
Lisp usepε@NA¬fAC\↓KgGCAJAGQ¬aCGi∃d\~∀4∀@@@A∪LAUgKHA]SiPA5←eJAQQC\A=]J@A¬eOk[∃]hXA%hAISYSAKf↓iQJA→Segh↓CeOk5K]h@↓ErAi!J~∀@@@Ae∃ghA←_@AiQ∀ACeOU[K@;'→9↓↓∧K⊃βW≤+⊃β←M#!↓β}s3eβ|¬f*α ≡&/.\X NEλ~5∧∧≤Y=∞↑Xπ9P≥42FEλ⊂⊂⊂⊂→4|7:[P92aZx97qXv⊂7`& that jumber, @]QSGP↓Sf@ZDX@`XbP⊃β⎇⊃βWlLV&NlX ∧ →<→-l~;YaQHλλ∧∧≠{@∞⎇→=~ ↑H≥~ T≠];,,<H⊂∀\β %1 ha`%≥JP@b0A←d@@X~∧~(@@@@@@@@@@@@P↑NRz|@bαaβS#*β'β↔w#'Se∧∧Vf.\Yg"pQ$ααα∧∧ααα∧∧ααα∧¬αzzε&αrβU∀βkrεAPRα∧∧ααα∧∧ααα∧∧ααButβ β¬`β~β%∀βkrε⊂
Ea"Hλ∧∧λλλ∧∧λλλ∧∧λ→5 5C"C!!"L*d∧λλλ∧∧λλλ∧∧λλλ∧∧λ∀u(
H ≡Yc"AQHλλ∧∧
"d∂
(∂'d≡
l%Dλ≡λ
↑<⎇λ ,(_ ⊂→αixnum* The result is always a fiXnum.
1) SUBR 1 arg
¬
(1- x) => x-1. x must be a fixnum. The result is always a Fixnum.
\ SUBR 2 Args
(\ x y) retuRns the remaifder of x divided by y, with the sign of x. x and
y must be fixnums. Examples:
(\ 5 2) => 1
(\ 65. -9.) => 2
(\ -65. 9.) => -2
\\ SUBR 2 args
This subr of two arguments is like gcd, but only accepts fixnums. This
makes it faster than gcd.
December 5, 1977 ∪2-6.4 Page 2-75
**DRAFT** Maclisp Reference Manual **DRAFT**
↑ SUBR 2 args
↑ is the fixnum only exponentiation function. It iser than
expt, but requires its arguments to be fixnums, uses fixnum arithmetic, and
always returns a fixnum result, which will be incorrect if the true result
is too large to be represented as a fixnum.
Page 2-76 ∪2-6.4 December 5, 1977
**DRAFT** Numbers **DRAFT**
Flonum Arithmetic
These functions require their arguments to be flonums, and always produce
flonum results. If the true result is too large or too small to be represented
as a flonum, an arithmetic underflow or overflow error will occur. (In the pdp-
10 implementation these errors are not detected in compiled programs.) The
compiLer producEq highly-optimized code for these operations.
~∀,H@@@@@@@@@@@@@@A1'+¬$`A←d↓[←eJ↓CeOf4∀~∀@@@@V⊂AeKiUe]fAQQJAgUZA←L↓SifA¬eOk[∃]if\4∀∩∀@@@@@A qC5aQKfh~∀@@@@@@@@@@@@@P,H@h\D@f\BPR@z|jP→I h)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓!Z!↓↓Ipεαβ
fTααk5fbJαπSbαk¬b⊂hR∧∧ααα∧∧ααα∧∧ααᬬ2"β%`
E∀∂/Hε%MHλ∧∧λλλ∧∧∞⎇≤M≡Z8;∧ x8p∩CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀∃I∀P⊂≡O⊂_↔_λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂≥tb→w:4j≡P2v"[p¬ft
λ
α
-$ LSUBR 0 o@HASOE∀ACeOL~∀4R↓↓↓↓¬##'Mαβ'Mβ&C∃↓β4¬F}w]P -⎇[≡(∞≡8]≤L≤⎇~3mdλ→]-l⎇~3meHλ∃m 9Hλ∞↑y9⊂≥tz4λ7w6,H7w2FB⊂⊂⊂⊂λ0y3z[pp∞t id p¬Ki@,ε&w~∧
FF*
nVn⊗↑ nP⊂72YβatiOn. Otherwise, it p¬KiKβ∪;Mβ&C∀4$∧ααα i↔.⎇λ⊂. ⎇;9-nλ≠:-n<h∃
(≤Y.≡λ≠p∪λ842P_y3p∃@5K]iF8~∀4R↓↓↓↓α↓↓↓↓α↓↓↓↓αA5⊃¬βiy↓Aq↓1βSF)β'∪,sS'SJβ↔3↔n+;P4R↓↓↓↓α↓↓↓↓α↓↓↓↓αA5⊃β@I↓↓urβS#∃εs↔∂παM⊗}r
x D∂λπεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
⊗R⊂≠ _⊂→π
TP≡@> 4.5
λ (%$2.0 1.5 -3,6) => 3.⊃
etc,λ
∀~(~∀THα↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓α2≥*
I↓αβ?Iβn{K∃β∂∪↔L4Ph!↓↓α↓↓)⊃∧ε&/'↑-g
πM Rππ-|G.∨D v $~=≤d <Y⎇-\8π:9K⊂⊂"|_vx6 %q:¬
(*$ 3.0 2.@@h\`$@z`9β⊃Q9@hQ↓↓↓α↓↓↓↓α↓↓↓↓BQ⊃↓Ys %↓ur↓Q9Eα↓↓↓↓α↓↓↓↓α↓oSKO3'π1∧≠πO∀hQ↓↓↓α↓↓↓↓α↓↓↓↓BQ⊃%↓iq↓E9α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓o'∪.sS'SJβ↔3↔n+;P4Ph(4(hP4*∪.≠↔7 /⊃↓U1β e]]α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓↓→I5Ys!↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓α∧ ∨¬↓⊂i]\4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK.3↔K↔v≠∃α↔∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~ ¬"Ph!Q hRt@ααα∧∧ααα∧∧ααα∧∧αα∧J:T∃∩∧∧ε␈∩
]w⊗* ≡&/_Q!PRα∧∧α¬&
~2εO4∧π&FT ff↑n]Rn}mK∩ε&≡m↔≡Nβ{@∧ ];XnM;{KD∧λ∪[nL(≥~ ≡λλ∃
(≠X-\(λ≠lD≥~~.1"Hλ∧∧λ→U-l⎇~3md≠=<nD_Y(∞O<→1∧
;H_.∀λπWR ⊂9tg_rP&$\βp uses / as an esc@¬aJAGαCπKπ≥#↔I8hQ↓↓↓ααS#'~β∪G≠≥#'?9∧≠?7C/#↔Mβ&C∃βK.≠'CK}≠π1βL1β∨'6+9β?vceβ?v)βπK?+7↔≠"q↓α'2β↔'[,p4)↓α↓↓β7␈∪∃βSF 9β?v)βπK?+7↔≠"aβ'Q∧∧FO6≤LW
πM Rε6≡.7"ε/∀π&FT∞&/∨EaPPh$∧ααα∧∧ααα∧∧ααᬬr`4
(∂'d +@_ ⊂:42H4r2w≥4z<P→v2vr[:εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀ WR⊂~K_⊂P≡O⊂_↔→βE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀↔WI⊂≠↔→∞⊂→W_M∀P≡Oλ→↔_εB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀∪WRλ_X_↔ ⊂→W_λ→↔_∀H≡←⊂_M↔~FEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂→z1WεBεEεE UR⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀ja)⊂ P0y3CEαE⊂λ⊂⊂⊂∀ UR⊂<
P≡←⊂≡∃XW_ ⊂⊂<⊂≠zyz⊂_2P0P→67w:[W⊂⊂*~2P92\zv:⊂~yP0v≥p|yP_P36'[:vWεBεEεE TR⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀ja)⊂ P0y3CEαE⊂λ⊂⊂⊂∀ VR⊂<
P≡←⊂≡⊗XW_ ⊂⊂<⊂≠zyz⊂_2P0@→67w:[W⊂⊂*~2P92\zv:⊂~yP0v≥p|yP_P367[:vWεBεEεE↔∩⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀ja)⊂ ⊂0y3\FEεEλ⊂⊂⊂⊂↔∩⊂4yH:42P→67w:[Vsw6≡P2|8≠w2w:~pz4w[⊂3:w_z4ww ⊂⊂*4→P34y≤z⊂0y→zvrw≥⊂⊂6z\z⊂12CE⊂⊂⊂λ⊂0P3≠7w:vK⊂:42H9rqw[2⊂6z\z⊂12H0P34↑7:vP
92x2Xz⊗⊂ H34|7≥vTV⊂_w2⊂:~2P92\zv:⊂~yFE⊂λ⊂⊂⊂0H367w≥vW⊂⊂∃7P90ZyrP0H367w≥vP:7H0P36≠w:vP≤7{ry ⊂:yrH∀2|8≥⊂<⊂<JP7y⊂λ∀2|8λ∀∃∩εB⊂⊂⊂⊂λ<P∀6≠sP<∀JTWεEβEεEεBεEεEβEεEεBεEεEβEεEεBεE(0YrP→⊗M\⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧Y⊗[↔
⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂"2qYvq2yλ~V⊂_N[[FEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂':vX2y9Pλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*¬
εEεEβE≠↔~H⊂"|8≠w2w:~pz4w[⊂0w2λ&7sp\4z46H#:w1]4ww9CEαEεB9xy:λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ)ja)λ_P0y→FEεEλ⊂⊂⊂⊂
9xy:λ<∀P≡O⊂⊂0P→67w:[P;t4Xt⊂4yH⊂:42H9xzp\2P97[z⊂7sλ⊂:42H7:vq→y⊂<↔λ⊂⊂*4~yP4yCE⊂⊂⊂λ⊂6wy→P⊂0qXzy0z→P:40[⊂⊂∀2↑8:⊂<λ⊂_↔~JW⊂⊂*~2P⊂3≠v67{Zw3P1[r2V⊂λ;t4qZ⊂4yPλ2:rP≥7FE⊂λ⊂⊂⊂#[yx2i ⊂9t7]v2⊂!→P;y4]82w~s⊂:4→P9xzXy2P9≠wz⊂7Y⊂0P!~sw:vH4yP2→yty2Y↔⊂⊂$]⊂4qFB⊂⊂⊂⊂λ2yyr[:4pv≠<P0@λ'2{z≠w⊂4j→y0z4[w⊗⊂;Zz4⊂⊂_x897\94pz→P892Xpzz4[w9P⊂→5y⊂4[:2sr\∧E⊂⊂λ⊂⊂:9≥w1pz~ww↔εBεA⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀2→s:w_9xy:λ∀7∀FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀_9xy: P⊂λabq n)
(e@aah@dP↑↑@ bV@Q!CkY←9JA\R$@dRR$R~∀~(@@@@@@@@QIKMβ+9β ≥ KAEαC9β∨,∧W∂~⊃Q"αα∧∧ααα∧∧ααα∧∧ααα¬
F∞n,L∩αFl[π"HQ$ααα∧∧ααα∧∧ααα∧∧ααα∧¬ε≡}lDαBFL↑7∨α
lWG" }V/∨5⊃PRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα¬ '∨∂.B∩εr
lWG"∃⊃PRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∞Dε?.↑>2JJ⊃Q"αα∧∧ααα∧∧ααα∧∧ααα¬∞↔.␈M≤Vw"¬∞εg/4 w./>4αG∂]}FN.nDεrε}\W∨~∃⊃PRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧ε"JJ⊃Q hPQ,WGα∧∧ααα∧∧ααα∧∧ααα∧
5,∃$ε∩ε∂,qPPh$∧ααα∧∧ααα∧∧ααα∧∧π@h$∧ααα¬ WGα∂¬∩βkd PhPQ!PVf|tααα∧∧ααα∧∧ααα∧∧α¬≥X*"β
≡&8h!Q"αα∧∧αFf|tπBJπWbπ& Tεv∂N↑&∞b
Mv>∂-≡FFj
|bπBaQ hPQ!PPh!Q hPQ!PPh!Q hTL\6.n,↑"β*Dε∪K;t∧ααα∧∧ααα∧∧ααα∧∧ααα∧α3∩kefRαα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα
⊗>*ε%S;HQ bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hSefbα¬N-⊗>}m⎇V/'-≤2∧7]l7&N⎇n0hPQ!PW≡≥dααα∧∧ααα∧∧ααα∧∧α¬≥X*"β
≡&8h!Q"αα∧∧αG≡≥dπBJ ⎇↔6/4∞FF*∧∞G⊗N⎇⎇f}n↑N&N~∞=⊗v*
|bπBd∧πBα
≡2εNd∞&∞&≤≥g~r∧∂αεn∨∀αε⊗T ⊂hR∧∧ααεm∨εw.T
w∩ε∀ ff}n]Rph!Q hV=}2αα∧∧ααα∧∧ααα∧∧αα¬:X%∩β∀ ↔⊗8Q!PRα∧∧ααF=}2πB∀∞&/'↑-g~πM Rε≡}=⊗v*
|bπBd∧πBε≡4εNr∞,⊗&N≥n2rα∂∧εn∂∀ &*ε∀ fOFn]Rαε}$ελh$∧ααα mF}w]U`hPQ!PV∂L≥bαα∧∧ααα∧∧ααα∧∧α¬≥X*"β∩ ≡&?_Q!PRα∧∧ααF≡L⊗rπ∧∧πJJ∞,W'/-n2απM Rε∂,>F∞v|]g"α
|bπB␈∃BεNd∧π⊗∞M≤⊗w~d∧πBα ≥f"π∀∧εn∂∀ &(h$∧ααα m↔Fw]↑2ε␈$ ff}n]W~r∧∂∩εn∨∀ε⊗*ε∧ε∂~
Mvv: ≡2πB
≡2εv}Dε∞g=tβαpQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ*ε∞>Tε"kC∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α↓≠%Vbs2∧∧ααα∧∧ααα∧∧ααα∧∧αααλLV≡.\,W∩βUDβ KvqPPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αα∧n]V⊗/.4ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hSefrα¬,≥f&}Tλg.v>M⊗}w1Q hPQ.&∞vM⎇Rαα∧∧ααα∧∧ααα∧ E≥,*$βαπ fixnum.
(random nil) restarts the random sequence at its beginning.
(random x), where x is a fixnum, retqrns a random dixnum between 0 and x-1
inclusive. A useful function is:
(defun frandom ()
(//$ (flkat (random 10000.)) 10000.0)))
which returns a random flonum between 0.0 and 1.0.
(random n⊃ n2) sets the random number seed from the pair od integerq n1,
n2.
¬
zunderflow SWITCH
If an intermediate or final fhonum result in the interpRetive arithmetic
functions (times, *$, expt, etc.) is too small in magnitude to be
represented by the machine, corrective action wilh be taken according to
the zunderflow switch.
If the value of zunderflow is non-nil, the offending result will be set to
0.0 and computation will proceed. If the value of zunderflow is nil, an
error wilh be signalled. nil is the initial value.
In the pdp-10 implementation compiledcode is not affected by zunderflow if
the arithmetic in question was open-coded by the compiler. Instead,
computation proceeDs using a result with a @ S]CedAKqa=]K]hdjl@↓QSOQ∃dAiQ¬\~∀@@@Ai!JAG←IeKGh↓Kqa←9K]h\α↓α'9αβS#∃∧kW3SL≠@~ε≥↑εf.\Yg&∂M≥vrπ.Yf&/,mF␈:∧∞v␈⊗>4π&FQQ"αα∧∧π≡∞\Tε6←$ 6}o
→F." 9v&* ≡2ε6} εNwL↑'π⊗↑LV"ε=x UC"C!$λλλ∧
y9(¬∞|⎇_.N<h→
≡Y⎇J%D≥z~,=λ_smn≤[{∞P24{~ytwwλ1<P-→y3P∀≤0y2 U≠TWβE
α
DeCembe@H@jX@Drfn@@@@@@@@@@@@@@@@@LdZl\\@@@@@@@@@@@@@@@@@@@@@@A!¬OB@DαiaD∀P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK,3↔K↔v≠∃α↔∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓ T"Jε~ ¬"Ph!Q hSecαα∧M|vN≡≥D∧oε↑,↔&N⎇n2ε}d g.n,↑'λh!Q hR∧∧¬&F↑8Rαεn]f∨&≥⎇g~α
\↔Jα ,Rαπ↑8V"εn,V.g∀∧ε6←$∧ε⊗OD∧εn∞m_ ∞]_=~-⎇Nhλ∞M→(⊂m⎇<~3 ↑C"TL\{y{M∨Y<h∞M→; ⊂_w2⊂8≤7r:aYyP2s→4qtr[:⊂1gY2WεEβE17w[2P⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂&)jP)⊂→P≠y⊂6w\2P0y→yFEεB⊂⊂⊂⊂λ∀17w[2P5@≡⊂<TP_wvx:]2yP0H14r⊂_<P14]⊂!7w[2pw→:w1j~ww⊂7Yα the fixnums x and y
under @QQJAGα{;SK}aβ/→εY9↓βZβ7WO"↓β ∃ε β≠'FsW5β⊗+SO↔,q↓Aβ∞s⊃↓E:↓↓#?∨#π1¬p∧α∧NaQ"αα∧∧π&FT∧ε⊗Nl≡'Jπ,↑π⊗/<Yg&∂M≥vrα
xbεZ∧
↔4λ_8L< λ∃
;Hλ∞M→(≥∞∞=~λ∧∞_8[ Tλ→Sn⊂:42CE⊂⊂⊂λ⊂!7w[2pw≠x2y0]4ww~y]εEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ<@
←←←←λt←0λ←←←1λ←
0| a c
x |
1l b d
α IF booLe has mgre than three a`%≥k[K]QfPASPAO←KLAMe←4AQKMPAi↑AISOQhlAiQkL~∀4R↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓β⊗{?3∃εYβaβJβi%↓h↓# ∨}c∃β-αC ??d)β-β@βe%βRH4(∀R↓↓↓↓¬##∃βn{OQβ≡{77?rβ[π3.+Eβ≠⎇⊃β-β∂∪∃↓EαCπ;⊃Ja↓]↓F{I%1β1↓#c⎇⊃%)↓¬K?Uβ≤∧⊗rε|ZBπ& QPRα∧∧αε≡⎇↑εf.\]g"b
}"εf|⎇⊗≡∞Dλ L\x=~-⎇Kλ∪lD≡λ_O∀λ∧17[v2P≠λ<⊂⊗XJWεEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂*42H37v&≠{tw3H6pqy≠yP0y→P7s:→w⊂1`/nvenient:
α (defun lOeandmacro (p)
(subst (cdr x) 'f '(bgole 1 . f)))
¬
(defqn logor macro (p)
(subst (cdr x) 'f '(bgole 7 . f)))
(defun logxor macro (x)
(subst (cdr x) 'f '(boole 6 . f)))
Page 2-82 ∪2-6.8 December 5, 1977
**DRAFT** Numbers **DRAFT**
Alternatively, these could be defined with macrodef (see part 6.2):
(macrodef logand x (boole 1 . x))
(macrodef logor x (boole 7 . x))
(macrodef logxor x (boole 6 . x))
lsh SUBR 2 args
(lsh x y), where x and y are fixnums, returns x shifted left y bits if y is
positive, or x shifted right |y| bits if y αis negative. Zero-bits are
shifted in to fill unused positions. The result is undefined if |y| > 36.
The number 36 is implementation dependent, but this is the number used in
both the Multics and pdp-10 implementations. Examples:
(lsh 4 1) => 10 (octal)
(lsh 14 -2) => 3
(lsh -1 1) => -2
rot SUBR 2 args
(rot x y) returns as a fixnum the 36-bit representation of x, rotated left
y bits if y is positive, or rotated right |y| bits if y is negative. x and
y must be fixnums. The results are undefined if |y| > 36. As with lqh,
the number 36 depends on the implementation. Examples:
¬
(rot 1 2 => 4
(rot -1 7) => -1
(rot 601234 36.) =6 601234
(rot 1 -2) => 2⊂00000000 0
(rot -6 6) => -501~∀4∀∩¬)!JAM←1YP∨←Ls≥β≠,∧↔'∂,Tε}vO∀ε/F≡>G4~;@∞M→(∀ N ($∧
;<≠ ]9;] ≡~;{EA C"D∧λλλ
M→(∩-n→<[L≥λ≤Y.∞Y<q-n_9~-⎇H≠p∪λ367w≥vyP6X|P12H40quYp⊂:yZw3P*~2yrP→8s1j~ww9WβE⊂⊂⊂λ⊂69tλ5y⊂ 2ot applied to a flOnum operates oN the internad pepres` ]i¬iS←\↓←L~∀@@@AQQJ@A→YW]k4ACMHAeKiUe]fA∧@AMSa]kZ@↓eKgk1h\@A→←d@A∃qCKa1JX@Q1cP@@@\j@@@R@z|4∀@@@@d``P````@```@!←GiC0RP→↓¬##∃β4¬vff}⎇⊗v: nVv∨M≥vrε≥N6zε←
↔∨'7!PPh!Q$&.<YV⊗/$εRbβ↔⊗s:α∧∧ααα∧∧ααα∧∧ααα∧∧αα↓6%S2s∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬ε≤|Rβ∩Wε0hPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hVn<2αα∧∧ααα∧∧ααα∧∧αα¬:X%∩β$ ↔⊗?1Q hR∧∧ααα n6~α∂∧πJJ∧∞ε/⊗m}&o~ ∀α∧584εNw>N'.∨M≥vrα
⎇bπ& Tαπ'⎇tεw.\,W↔~∧∂αε∞lDαπJD ⊗v Q$ααα∧∞&/'↑-g~πM Rπ⊗↑>Vg" ≡2ε
mF}w]Ubα∧=⎇g∨.NDπ&FT∞ε'αV⊗αππ-|6/∨=}"εn≥nV∞b
≤bπN}QPRα∧∧απ>≥nBπ&t∞W≡*∞MεO~aQ hR∧∧ααπ∧∧ε∞vD∧πJα∧
V∂J∧ &*α m↔Fw]↑2αε}$ααεmMvw.↑72αεn<2αε.↑7"α∞↑6/~∧∧π&FT∧εn∞=
⊗v(Q$ααα∧∞&/π,↑6.wL≡FN}n4ε}2∞Mε*εn]V⊗/.5bα∧≤dπJε≡4ε?⊗\≡F/∩∞Mε∞rεvs;;vtε}∨L≥BbπM R∧581PRα∧∧αεNn>G↔.>M⊗}r
≡2ε}]≡G&.D ⊗v"∧∞FF*∞
w∨≡≤-GJo]mf␈⊗\≥FOV\Dε6f⎇nVjπ⎇≡FBα∞Mε*π<≥V(h$∧ααα
\⊗≡F≥lRπ⊗↑∞&/≡]nF∂&≥⎇bε∂4∂αεO4∞&/'↑-f."aQ hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh* ⊗>*ε%SC"∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧↓≠∩VecBα∧∧ααα∧∧ααα∧∧ααα∧∧αα∧L\6.n,↑"β*Dε∪K;qQ **DRAFT** Chabacter ManiPulation **DRAFT
*
7. Chabacter ManiPulation
7.1 Character Objects
¬
An atomic symbol with a one-chabacter pname is often called a character
object and used to represent the ascii character which iq its pname. In
a`dition the atomic symbol with a zero-length pname represents the ascii null
character. Functions which take a character object as an argument usually also
accept a string one character Long or a Fixnum equal to the ascii-code value for
the character. Character objects are always interfeD on the oBarray (see page
2-58), so they may be compared with the f@U]GiS=\AKb8~∀
∀4∃CgG%R@@@@@@@@@@@A'+¬H@bACIN~∀~(@@@@QCgG%RA`R0AoQKIJApA%bABA9k[EKHXAeKQke]f↓iQJA
QCeC
iKdA=EUKGPAM←dAiQJ↓CgGS$~∀@@@AG←⊃JAp\4∀~∀@@@A aC[aY∃ft~∀4∀@@@@QCg
SR@b@bR@zxAα~∀4∀@@@@QCg
SR@jXR@z|↑\~∀4∀~∃O∃iGQCH@@@@@@@@@@A'U¬$@d↓CeOf4∀~∀@@@@Q≥KiGQ¬dApA8RXAo!KeJA`ASfA¬\@ACQ←[SF↓gs[E=XAC]⊂A\ASLABAM%q]kZ0@AeKQke]f↓iQJ~(@@@@↓\OiP↓GQCe¬GiKdA←LA`OfAa9C[JvA\@zb@Ag∃YKGiLAiQJ↓YKMi5←gh@↓GQCe¬GiKd8@A)Q∀~∀@@@AGQ¬eCGi∃dASf↓eKikI]KHA¬fABA
QCeC
iKdA=EUKGP\@A]%XASf↓eKikI]KHA%LA\@¬SfA=kh~∀@@@A=LAE←U]If\4∀~∀~(~∀~∀4∀~∀~(~∀~∃⊃KGK[ Kd@j0@brn\@@@@@@@@@@@@@@@@@&dZ\\@@@@@@@@@@@@@@@@@@@@@@@↓!COJdZpj4∀_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∃OKQGQCe8@@@@@@@@@A'+ $@dA¬eOf~(~∀@@@AOKQGQCe8ASfAQQJAg¬[JACLAOKi
QCdA∃qGKaPAiQCPAiQJ↓GQCe¬GiKd↓SfAe∃ike]∃H@ACLAB~∀@@@A→Sq]k4AS]gQKCHA=LABA
QCeC
iKdA=EUKGP\~∀~(~∃[C-]CZ@@@@@@@@@@A'+ $@bA¬eN~∀4∀@@@A[CW9CZAi¬WKfA¬fASiLACeOU[K]h↓BAYSMhA←L↓GQCe¬GiKeLAC]H↓eKikI]fAC8Ak]S9iKe]∃H~∀@@@ACQ←[SF↓gs[E=XAoQ=gJAa9C[JA%fAG←9giek
iKHA→e←ZAQQJAY%ghA←_@AGQ¬eCGi∃ef\@↓)QJ~(@@@@↓GQCe¬GiKeL@A[Cd@AEJAeKaIKgK]QKH@A∃SiQKHACf@↓MSq]U[f@@!CgGS$@AG←⊃KfR@↓←dACL~∀@@@AGQ¬eCGi∃dA←E)KGif8@A q¬[aYJh~∀~∀@@@@@@@@@@@@@@@@@@@@Q[CW9CZ@N!BAD@X`AHR$@z|A¬DaH~(~∀~∃%[aY←⊃J@@@@@@@@@@AM+¬$@DACeN4∀~∀@@@AS5aY←I∀ASfAQQJ@AMC[JA¬fA[C-]CZA∃qGKaP@AiQ¬hAiQ∀AeKgUYiS]≤ACi←5SF@AMs[E←0ASf~(@@@@↓S]iKI]KH\A∪hA%bA[←IJAKM→SGSK9hAiQ¬\AI←%]N@Q%]iKe8@Q[C-]CZA`RRXA¬YiQ←UOPASP~∀@@@ASf↓YKgf↓KMMS
SK]h↓iQC\↓aYCS8A[CW9CZAo!SGPAMQ←kY⊂AEJAUgKHA]QK\@↓S]iKI]S]N↓Sf~∀@@@A9←hAe∃ckSe∃H\~∀4∀~∃e∃CIYSMh@@@@@@@@@A'U¬$@b↓CeN~(~∀@@@A)Q∀ACeOU[K]h↓i↑@AIKCIY%ghASLABAY%gh@A=HAGQ¬eCGi∃ef\@↓)QJA
QCeC
iKefA[Cr↓EJ~∀@@@AIKaeKMK]iK⊂AKSi!KdACLAMSq9k[f@QCgG%RAG←⊃KfRA=dACf↓GQCe¬GiKdA←EU∃Gif\A)QJ4∀@@@AGQCICGiKIfAS\↓iQJ@↓YSgh↓CeJA¬ggK[ YKHA%]i↑@↓C\A&5Kqae∃ggS←8ACfA%L@Ai!KrAQ¬H~∀@@@AE∃K\AieaKH@↓S]i↑↓eKCH@QgK∀AaCeP@j\b8R@A∪_A[CGI↑@AG!CeCGQKefA¬eJ@AUgKHX↓C]r~(@@@@↓kgCO∀AS\AQQJA[¬Ge↑A
QCeC
iKdA→k]Gi%←\A←_AeKC⊂XAeK¬IGPX↓isRX↓←d@AQsSaK∃VA]←P~∀@@@AKqAYSGSQYrAgAKGSMeS]NA¬\AS]Akh@A→SYJAQCWKf↓S]akPAMe←4@AeK¬IYSgQfOfA¬eOk[∃]h~∀@@@AICiQKHAiQC8AMe←4AC\A$←≡AI∃mSGJ↓←dAB↓MSYJ8@A)Q%fAGCUgKfA5CGe↑AGQCICGiKIbAi↑4∀@@@Ao←e,ACfAe←jAo=kYHA∃qaKGP\~∀~(@@@@@@A aC[aY∃ft~∀@@@@@@@@@QeK¬IYSgP@NQB↓DAFR$@z|A¬EF~∀@@@@@@@@@QeK¬IYSgP@NP@<PA`AH@bjb↓\Ah@<@@↑N↓LA↑A<@↑R@$R~∀@@@@@@@@@@@@@t|@QaIS]h@!ck←i∀AM←↑$R@@w¬gGSRbbb@t@ERD4∀~∀@@@A≥=iJAi!JAkg∀A←LAQQJAg1CgQS→SKHAMaKGS¬XAGQ¬eCGi∃efAY∃Mh@AACeK]QQKgSLXAga¬GJX~(@@@@↓ck←i∀XAeS≥QhAa¬eK]i!KgSf↓S\Ai!JACE≥k[K]PAi↑AIKCIY%ch\~(~∀~∃ACOJ@HZpl@@@@@@@@@@@@@@@@@@@@@@&dZ\Xb@@@@@@@@@@@@@@@@A ∃GK[E∃d@jXbrnn4∀_TU Iβ
(T(@@@@@@@@@@@@@@@@↓∂#πα,⊗∨&↑ λ \8π4`0ula`)%←\@@@@@@@@@@@@@@@@@)T"Jε~ ¬"PH!Q hV←∞εf@y→(∧∧λλλ∧∧λλλ∧∧∀p
a∀⊂_P !pg
λ∧@@@@QKqAYP∨∪*βa%↓∧ε&/'↑-g4_(⊂⊗~yz⊂⊂≠q⊂1`(arac@QKefX↓oQSGαA↓βπα,Rπ~→(∧ z_<L≤⎇→0→≤β thatλ
)α↓↓↓β>{W3⊃∧∧&*πLε0_→p∧ @=khASα1↓#C⊗K9Eβ@¬∩απ|X LT→≠p↔→T∧ i@9GYkI%]NAgαcπO#,ε2αεmx D∞|→0⊃Zpp
cha`%¬GiKeLAEkhαβ; ?Dλ
-l{_
`$ing @∃q`∪Kλ∧εv/⎇H
-l<h⊂∀[9ry:→p∧ to preventcha`%¬GiKeL~∀@@@AMe=ZAe@,¬fvNβY`⊂λ4πff the p¬SOQPASCe≥S\\@AβCG AGQCICGiKβ⊃↓β'~β@⊗/∞,W∞9]→,Dλ_↑$ εE⊂λ⊂⊂⊂!Z0y0q]2y⊂ /bjecT,∧@A aC[aYα)`⊂H!Q"αα∧∧ααα¬ WGεMxF*αu↓2α{⊗ β~J∀πSrα∧¬rBα4¬rααutαk
∧¬s∩αt∧αk~¬u∩αHβ"H∧∧λλλ∧∧λλλ∧∧λλλπ→β3p∀e the presEnce od∧AgY¬`∂#'4K↔↓β∨βπ∂↔~β'9β&C'MβdK@∨"aQ hPQ( /∞≠≠q \hλλ∧∧λλλ∧∧λλ∀jXTH $ <Yc!! ¬⊂⊂λ⊂⊂∀2↑867b→qP<∧H⊂92z≥y0∞s a liSt oF characterpεAoQ%GP@A¬eJAi!J@AG!CeCGQKefAQQCh~(@@@@↓o←kY⊂AEJ@↓isaK⊂A←kh↓SL@@!aeC] ApBA]KeJ@↓I←]J0A]←h↓S]GYUIS]Nα↓β↔c'∪¬β;-;3';-_4)↓α↓↓β'w≠↔KS.!βS=πβK↔[,sQβ∂F Kπ∂&+KMβ7∪?5β↔+;;'v9β?≠2βS#∃π∪'∨#"↓β7π⊗;'99ααOC↔≤Kπ04R↓↓↓↓ε≠#πK∞≠S↔K~↓βπK*↓β;?"↓βO3∂≠#'≠N+⊃9↓αα↔π∂B↓β∂#∂∪π∂S/⊃↓β'~↓βK↔π∪↔O↔w#↔⊃↓ε∪e↓βλh)↓↓α↓β∂#∂∪π∂S/⊃β? V+∂Q9αα↔cπoβ3∃hhP4)↓α↓↓↓↓α↓#↔cεc?∪↔~↓≥!-αyEI↓~I%↓ur↓!↓=@↓-↓=α↓=E↓{⊃↓=↓αyM↓≥J↓$4(hP4+↔Gβ3?∪.q↓↓↓α↓↓↓↓α↓↓αN,∩I↓E∧ K≤4Ph)↓↓α↓↓#↔Gβ3?∪.qβa%αβK↔S-∪;Mβ
β3'O"↓β?→ε≠#πK∞≠S↔K~β←#'≡A↓βπ⊗)βS#*↓β∂#∂∪π∂S-∪EβSF P4$∧ααα∞⎇w.fDλ&*α∞O↔ε.D
w/"
≤bαα∞∞&Nv4∂αJπ|↑&*α Mvv*D
f␈"
≥f≡g\M⊗v:∧ WGπ,∀εv/⎇M⊗v/1Q"αα∧∧εNw<X NL9λ≥
t≤≤Y.l;]λ =_8X,>→<\d \[{$∞];[M≥Yh≠llH≥~ T≤Z9m∞λλ≠,≡Yz;Edλ∀t \z8;↓QHλλ∧∧_z_.,er
which is the ascii code for that character. cf. explodec. Example:
(exploden '(+ /12 3)) => (50 53 40 61 62 40 63 51)
flatsize SUBR 1 arg
(flatsize x) returns the number of characters prin1 would use to print x
out.
December 5, 1977 ∪2-7.1 Page 2-87
**DRAFT** Maclisp Reference Manual **DRAFT**
flatc SUBR 1 arg
(flatc x) returns the number of characters princ would use to print x out,
without slashifying special characters.
Page 2-88 ∪2-7.1 December 5, 1977
**DRAFT** Character Manipulation **DRAFT**
7.2 Character Strings
These character string functions only exist at present in the Multics
implementation of Maclisp. A predicate to test if your implementation has these
functions is
(status featuRe strings)
These fUnctions all accept atomic symbols in place od strings as arguments;
in this case the pname of the atomic symbol is used as the stping∞ When the
vAlue od∧A←]∀A←LAQQKgJ↓Mk]GQS←]f↓SfAI∃cGeS KHACLABAgQaS]N0AShA%bACY]Csf@↓BAgiIS]N~)C]HA9KmKd↓C\ACQ←[SF↓gs[E=X\@A¬Yg↑AMKJAi!JAMk9GiS←9fA←\↓aCOJdZjl8~∀
∀4∃GCi∃]CiJ@@@@@@@@A→' $@`A=`A[←IJACE≥f~∀~(@@@@↓)QJA¬eOk[∃]ifA¬eJAG!CeCGQKdAgQaSMOL\@@AQQJAe∃gkYh↓SfAB↓cieS9NAoQ%GP@A%`
βπf`4)↓α↓↓βSF)βπK?+7↔nN2ε≡⎇l6∂&]l↔&.D
F}≡↑Mε/∩d∧∧/F≥↑εf+!Q hR∧∧ααα∧∧ααα 8λ.L9X= TλY[mtHλK$$λXX.$J(∂'dλYSmu8X<D↓ C"AQX;Y ←λλλ∧∧λλλ∧∧λλλ∧∧∀q0J$ H⊂⊂\3yFEβE⊂⊂⊂λ⊂4w2→|⊂4yH64urH:42P∀&∪dP_:pv*~w⊂3 5nctiOn index. The arguments are c@!CeCGQKd~∀@@@AMieS]≥fT@AQQJAa=cSiS=\@A←_AiQJ↓ISegβ!β/∂≥+KK↔v≠∃↓β|1βS#*βO.=yf"α ≡& >;93ND~;C!$λλλ∧∞~→( M<\p~λ4yP9→z:y7→r⊗⊂'\⊂_⊂4Y⊂:42\2P4`3 none. ExamplEq:¬
(index "foobar "ba ) =x@h~∀@@@@@@@@!S]IK`@EM←=ECdDAECtλR@z|`~∧@@@@@@@@Q%]IKpAO←← CECE∧D@EE¬DDR@t|@h~(~∀
∃β≠SK'v;3↔≠?#!↓↓α↓↓↓↓¬~V
Iβ βπK8h(4 α↓↓↓α&C∃βπ⊗;W7↔w!↓βSzβOSKNs∨3↔v;S!βo+OQ↓ε∪∃β¬ε≠#πK∞≠S↔IαβOSKNs≥9↓¬##∃↓εsW7 -⊃β/_hQ↓↓↓αβ∂#π⊗ ∂S↔↔→β'9εKQβ'~βK↔S-∪;↔⊃r↓α↔c∞kC#↔≠P4(Q$ααα∧∧ααα∧¬π∨'-≥f>f]lw&B∧,f}z%∀βkrε1PRα∧∧ααα∧∧ααG>N&Nv⎇HVv?Mα$J(∂'d β"AQA"C!! Q→,<;8Y.$
+λε↔-m`∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλα6K-kF$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∀ ≤y( EW∞#"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~4n∧∀Y9L↑Y;XlT⊃8;N\;λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λJQ
(1U∃
εEεEβE9za≤z9⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂&)jP)⊂⊃ or # argc
α This iS like the PD/I substr builtiN. (substr x m n) @IKike9bAB@↓cieS9JA\~(@@@@↓GQCE¬GiKeLAY←]≤XAoQ%GPASLABAaα{@↔ε≥⎇bε↑d
FF*∞>G-9Y`⊂≡⊂12sZw74`.e wi@QPASiLARO@&@4)↓α↓↓β∂F Cπ∂&+Aβπv!βCK|∧6.∞M→f*εmz"εR 8
≡X8u ↑\k@∧
(_;LD≠H≠.↑⎇λ⊂LT→Z6
n;<k∧∂λ≠=.>β"H∧∧λλ⊂LT_(⊂→]94w3KεAεEλ⊂⊂⊂⊂
9zq9]9⊂<≠TP92]8¬rns the portion Od∧AiQ∀@AgiIS]NA`AEKO%]]@'v9βO'&A↓β''→β%∨αMhR∧∧ααε= ↔,8⎇→.∧_;Y∧ {{]
≥]:0↔→β until the end kf The stp¬SMNαq↓α↔F 7C3/→h$λhQ↓↓↓α↓↓↓↓α↓#OW↔≠SI↓⊗3?? ∂⊃↓↓Mβ⊃%↓ur↓ / ⊂h)↓↓α↓↓↓↓α↓↓#O.∪OSIα∪K↔O.cS'Wv;↔I β1%↓ur↓ C7.s∨↔I⊂h(4(hS∨πR␈β;π7*↓↓↓↓α↓↓↓↓ααNV
∩↓Eβπ⊗84(∀R↓↓↓↓αC∨↔R␈β;π7*βa%β⊗+SGKw→βS#*βC;πn)β?→αβaβπ~β¬β∂F Kπ∂&+IβO'∪';≥r↓βaβo+OQ↓ε∪∃βπph)↓↓α↓βπS}k'
β∨K7 ?bp4(∀Ph+7π↑*␈πS}i↓↓↓α↓↓↓↓α↓αNV∃⊃↓Eβ∂∪≤4(hQ↓↓↓αβ7π/-{πS?jβK↔S/∪;Mβ∞qβπS}k'
β∨K7 ?ba↓βWvK;S↔⊗s↔⊃1π;#?O*βC;πn)β'Mε;'[↔r↓βπMελ4)↓α↓↓β∂F Kπ∂&+IβO'∪';≥ε K∨Wn+;Q9αα↔cπoβ3∃hhP4)↓α↓↓↓↓α↓↓↓#n /⊗␈∂#?5↓⊗3?= J↓uyβ6{=↓↓α↓↓↓o>C'∂!εKEβ;␈!β↔Eπ#=β∧hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓o≠?zβS#π"β'Mβ⊗+π⊃βNq84(hP4(4Ph(4(hP4(4Ph(4(hP4(4Ph(4(hP4*C∞;∃↓IkIA↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓↓→I5]s⊃↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓α∪↔≡+7 ↔∩↓U1↓ I]\4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓α∂∪Kπg~↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~ Q(4(hP4(4Ph)a9ααπKK∂KL4(hP4)↓ααπMβ-CC3πNs↔⊃βLqβCπ↔!↓E9∩aβπ9ε KKπJβ'Mβ
β∨K?/↓β?→ε≠↔33~β←#'≡Aβ7πJβ∂?;& '9αfKG@4T{ +↔∨#M)↓¬##∃βL¬f&Om_ ∞\;λ⊂⊃Yv69P_y2P9Yv2q`4ed by numepical subscri`tq*
An array i@L@AIKMSO]CQKHAEdABAgAKGSC0@ACi=[SFA=EUKGPAGCY1KH@A¬\ACeICr[a=S]iKHX∩∃βIaCr[A←S]i∃efAG¬\AEJ↓eKiKI]KHA rAiQ∀ACe@⊗ e7∂⊗+πS'}qβ≠Wv≠S'?w→βπK⊗ eβπv!↓+π↔∪πe8hRπ9β∂∪Cπeoβ?';&+I↓βn eβ↔M##↔I∧∪∃↓β-≠↔⊃β&KC↔∂&ce↓β&yβK↔6+@∩πMtαπ& Tε∂↔,∨∩bα
z"bεmx AQX{sNl;Z0∩[1rP4[⊂⊂92Y2y94[3P:7H⊂:42H0y0∩ay thpkugh input/outpqt m` IS∧XAShASCr↓EJ~∃ββ3π∂,!β/9¬##∃βπ∪?C↔↔#eβ3M≠Qβ?2↓βπ→∧ S/7L∧2π∨≥\&}b∞Yf&/$λ
(~0↔→4qpz≠y⊂⊂ \90|Vλ0p∞d
λtheN that symbol can be usedas the name of the array.
~∀@A)Q∃aJACIJAgKYKeCX↓isaKLAWLA¬eeCsL\@A)!JA[C%\AisAKfACIJA←e⊃S]CedACe@⊗ gMD
vF␈<QPV≡]IG4_x;D
≠{⊃∧ ;↑(∞O<→(
|H≠xM,8⎇ ∧ ;Y
n;8Y.$_<\L∨<kλ∞⎇≠|y$ y;∪∞∀_x;D∧≠{[∂∀~≠s A"[]-\Y<\edλ∪]-\Y<H ≡\X>.4≤→<M]=λ≠-}Y(→,lZ8z,]]λ_m|→(≥
t_Y( ={<~-L9λλ m|H≠N]9<Z,<;β"L≡≤≠~,<=~;mnkλ⊂-lλ≥_-<(≠→.>h≤| ≤y(≥
;H_-d≠|Y
≥X<↑$ <\X/∀≥z~,=λ_{mn_:;N4≥~→$∞x;9!Q[];,,<H≠ldλ≠]-\Y<\edλ∀y,Tλ≥~ T_<\L∨*Hλ L8{_.,=~;md
≤_..λλ
¬fJ(_-lλλ≥
(_<N,>8x-Mβ"YN]X⎇~-⎇H
≤ ≤y( EV-
+AQC"H∧∧∃z→-d_;H ≡\X>$
<h_n,8=→,D~=≤d∧≥≡< T≠=<nD_Y( L8{_.,9λ_O∀→z=M≥Yh_$∧λ]≡. (_{lL+HC!*~→(∞O<→( =y→(∧ [|H
}Y~;L≡↑(_..X><d∧~<h∞EHλ⊃M}H≠]-\Y<H∧ <\X/≡kλ≥
(≥≡. (λ_m|→(~.1"Y:.M→<H m>≠]-T≠|H m≠{]-UHλλλ∀≤_<NM8⎇; ≡H≠]-\Y<H ≡\X>$∧_x;D
{[≡$
≠{→∧
{Y(∧∞≡<→$
yC"Mn;8Y..h_Y,<=<y$
=≤h <;≠≤d {{] ≥;H≥
(≠8,=~;Y$∞Y<≤L↑y;] ≡~;{D
yH≥
(λ≠N]8Y<ED≠[⎇↓Q]~→$ ~<|¬]xZY,>λ≤Y.∞Y<y-n_=~-⎇KC"AQHλλ
={9(
}~→<D∞≡<→.4λ≠yD <\X/≡h_<LWHλλ∞]K9x.,X9y%\{{≠ \⎇→9∧ <\X/≡kλ≥m≡~λλ ∀≥≡< U#"Xm|→(≠ldλ≠Z-Eλ≥z
≤zλ_.,(λ≥
(≤x-\(_<d∧≠|Y
≥X<↑$ <\X/≡h→> <<≥λ∧∞~_=∧∞~→>$∧_<Y$
[⎇β!.≤[⎇ \⎇→9∧∧_↑(∧∞~→( |<XX,|(λ_m⎇≠→8nM|Hλ ≥Yλλ∞M→<Y,m|Y( <;Hλ ,(λ≥.<9λλ m|H_l↑]_:-a"Y<m}→<Z,4λ~_,=|nh∧
xX<N,><k∧∞z=~∧∧_(λ∞O<→+,=y→(∧
yH≠l,<\X/∃λλ≥m
8zλ∧ <Y(∧∞<y9∧∞≠c"M\:;] ≥;H≥ ≤[→<d
yH~mm⎇{H ≡≠{:,4≤};,-{≤h∧∞{h≥
=λ≥
(≤x-\(_=
⎇:8h∞?;8[mDλ≥z-Mλ_Y!Q\Y9L↑Y;Xl\λ≥z ]H≥~ T≤x;,T≤≠X-\(~<d∞≡<→,D~;Nd ;Yλ∞,89≥ ≤[→<eD≥z=
∧_(λ∞O<→+,=y→(
|C"\L\9≥_,-ifications for the Lisp
input reader. Normally, there is only one readtable and one obarray, supplied
by the system, but the user may create additional readtables and obarrays in
order to provide special non-Lisp environments or to gain additional control
over the Lisp environment. Lisp functions such as read can be made to use an
additional readtable or obarray by re-binding the variable readtable or obarray,
respectively.
December 5, 1977 ∪2-8. Page 2-91
**DRAFT** Maclisp ReFerence Eanuad "*DRAFT(T~∀~(~∀@@↓β\ACI` πeoβ?'≠&+Aβ7∂I↓βπe≠=β *β∪↔π ¬Bαε≥`π>F≤9αε≡≤∧p∩H4z⊂⊂→5ryP≠7z⊂(≠tw:⊂λ:7P !ny¬
@¬aeCr8@A∂]∀AWLAQQJAMβ+;∂SL{;Mβ∂∪@⊗∂∃DαV∂,,↔JB
z"αW,X↔π⊗∨∀εn∂∀λ&*π↑8V"α∞Mrπ⊗↑h
.m9↑#! (→→,≤α⊂0y≤αay-poiftep.
λ The f@U]GiS=]fACI` πe∧∧⊗v"¬(↔π⊗∨∀ε∂⊗T
W≡.D
Fzε>,V∂&Tλ↔π⊗≥~2bα
Mε*εm_ N≡λ_<L↑;90↔≥∧@
may be an atomic symbol, @]QSGP↓[CGKβ→βS#∂!βπS|k'
↓π≠g7 |aβS#*β;π↔*β?→↓ε 9βπ↔∪πe0hSCWS&K;≥β∞qβπKα,↔Jo
y⊗w&↑ αε}d
↔'~∞λ M}→<]∂∀λ≠∩.≡ λ∪n∧≤Y9 \X;Z-lhλ_-d_<\L∨+<≠m≥]→<AQ]~_.D≥x<d ;_Y,≤≤(∪md≥~→$∞≤[| ↑]~(
M<⎇λ∞Mh≤≠m≥]λ⊂~≠P:42H72{Pλ0y10↑W⊂⊂ [:2y7_z4{2[<BE*~2P3 )p¬ghA¬eOk[∃]hA[¬rAEJ↓C\@A¬eeCr↓a←S]QKdXA]QSGP↓GCkg∃bAiQ¬hACEICr@AA←S]i∃dAi↑4∃EJAIKIKM%]KHAQ↑Aa←%]hAi<ABA]∃nACeICrXA=dASh↓[CrA JA]Sαa1β←FK∂!β≡ WO↔~β¬β;-9βπK⊗ d4+∧{';S/⊃βS=∧∪∃↓β≥∪↔πS.!βπ; βK↔S-∪;↔⊃r↓α↔c≡+CQ↓εK9βSF)β3π'#↔Iβ≡ O∃1αβπKK∂IβK↔'+K;LhS'SMε3'KO"βπK∨,k↔;Qp↓↓+π↔∪πeβ∞c←πg~↓βK↔'+K;Mπ##∃β∂∪Kπeπβ?';&+I1βv+[↔IαβS#∃ε S?7N_4+ONk ?1ph(4)α↓α¬β⊗+πβS∞∪3∃β␈⊃βπ9ε{ πK⊗ eβ7∂Iβ;?"β ∃β≥∪↔πS.!β←'&A↓βW≡+I7Oε+∂'≠N+⊃β∪Nk↔;OL{;M8hRS#∃ε#'7↔w≠'?;~βπK∃ε 3←πO→β∪↔&+K7'v+⊃↓β↔Iα3'∨↓9↓α␈##↔Iπ#gC↔~β?→β∂∪Kπg~↓βπ3f{]βπwH4+K. O?;∞∪3∃βw+7 ↔∩↓#πQεc↔πO"↓M1↓ε ;g←∂I%β?2β∪'7.sO'?w→βS=ε∪∃βOε+∂'≠N+⊃↓β>C↔9β&C↔d4T K∃↓ε≠K↔π&+⊃9↓¬##∃↓π≠W O∨∪'CS~βKπ;>)↓β≠⊗{5↓AαβWAβ&y↓↓Eεc↔OMαβS#πr↓βS#*β∪'7.sO'?ph+OC.≠'≠'.!84(hQ↓↓α␈∪∪';∂∪e↓β∞s⊃βWrk∨πK⊗ ∨∃7≡{33↔∨#↔⊃↓ε KKπO→↓βπ⊗)β';O#'π3OS↔⊃↓π#=↓βvK19↓∧3'c;.h4+π↔∪πgMε K∃βNs'S'∞c'k↔"βS=↓αq↓α≠f{;W5ε KKπO→βπK*β';'&Kπ3'V+⊃βSz↓A9Aph(4)α↓α? ∂∪Kπg~βπK∃εK;'SN 3'k.!↓βπ≡≠?K∪Ns≥βSzβS#∃π##'K"↓βπK?+7↔;"β∨'[.qβS=αβπKK∂Iβ?HhQ+πK⊗ e9↓εs'1β≡ WO↔~β¬β∂}kC3↔&+3eβ.kCSeε{ πK⊗ eβSzβ ∃β∨∪↔πS.!9↓αv{Qβ↔6+9β;Naβ←'f`4+ *β';S/∪;↔⊃ε{9βSFKMβ?⊗ KKπJq↓↓β"β∂πW≡+MβSF)β∂W↔∪↔;Qε{ πK⊗ e↓#6 3W∃ε{→βSF)βOgn∪?04V{ πK⊗ e%↓π#=β *↓β∂?εK↔⊃9ααπ9↓ε KKπJkC?'w#↔Iβ>C'∂!αβ'Mβ∞q↓β?⊗ KKπJaβ?Iαβπ9β∂#?7'_h+Ogn∪?1β>C'∂!εsπ7↔~βπ9↓ε{ πK⊗ e1β≡ WO↔~βS#π"β? π↔∪πe↓π#=β *β∂?CN+⊃9↓∧K→↓βvyβS#O∪⊂4+∂∪∨W7.sQβ'~β∨'[.q1βSF)β∂W↔∪↔;Qε{ πK⊗ eβ'~β∂?CN+⊃84Ph)↓↓¬∪↔π∪& 3↔~βπK∃εK;'SN 3'k.!↓β'rβ¬βONk'3π∩β≠πOFK?99α↓α'→π##∃β&C'K⊃αβπK∨.k↔;Qε{_4+∂∪Kπeε{I↓+∂∪KπeεKMβ;Na1βSF+9βSF)β∂W↔∪↔;Qπ∪↔π∪& 3∃εKMβ∂␈β'↔⊃r↓α'→εKQβ'~↓βQ1π##↔8hSS#∃αβK↔π'#π 3*↓β ↔Ns≥↓β∨∪↔πS.!↓β'~↓β';O#'π3OS↔⊃↓π#=↓β&C∃↓βNs'S'∞a↓βO& ;∪π⊗!α3'∨4+K. ∪Sπ⊗c∃1↓εK;∂3.#';≥π##∃↓εkπ∂Kzβ∂#π⊗ ∂S↔↔→↓↓≥ε ;⊃↓βY9↓↓Ds?S∃αβS#π"βS#'~↓β'Mπ##∀4V{CC?≡KS∃β}1βS#*βQ7;Naβ∂?w3↔;SN{9↓β6{Iβ?⊗ KKπO→9↓α&C'MβO→β≠?∩↓β∂?oβπS'⊗K3'SJβ←'S@h+S#*β7π/⊗+πβS∞∪3∃β7+;∂SN{91β>C'∂!αβ;=βf{;∨↔∩β↔c'∨#M9%∧ 9βπ↔∪πe7ε{';S/⊃↓β?∩βOg7⊗{04+}1β¬β⊗+πβS∞∪3∃β&yβ ∃ε≠?C'.!β7πJ↓βπ3≡yβ ∃ε;'[↔rq↓α'2β;=β&C'K⊃ε K∨Wn+;Q↓εKMβ∨O3↔90hSS#∃ε≠WKK.sQβK. ∪Sπ⊗c∃β'~β∂?CN+⊃84Ph)↓↓∧ 9βπ↔∪πe7ε{';S/⊃β7πJβ ∃β⊗+∪↔≠Ns↔⊃↓π#=βπrβ↔;SO∪↔3eε#'≠≠/∪↔;Qπ#gC∃ε ;⊃↓π≠'k∃ε{_4+∂∪KπebβWO'v9↓βSF)↓+π↔∪πe↓ε3W;∂&K?99αα'Q↓π∪↔7πNsMβSF)↓βO∞k∃βπ↔∪πe7ε{';S/⊃1↓β/ βS<hS'SO.c→9↓∧K→β¬π3πK'∞∪3∃β> MβO/#E∨↔"βS=β&C∃βπ↔∪πe7ε{';S/⊃1βSF Qβ[∂∪'π f)↓β←Nc1β;␈84(4Ph*Cπ>)↓I5K⊃↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠⊃5a9α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αα∪↔∂.k ↔Iβ)1↓EK9\4(1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓α∂∪Kπg~↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4+'v#'∂π&)βS#*↓β;↔:βπKK∂I9↓↓∧K→β¬π≠g7 }a↓β#∂→βS#∂!↓βπ↔∪πe7ε{';S/⊃β?9αβ'SMπβK?C/∪Sd4Vc'OQbβ'Qβ>K31βv{]β *βS#∃εsπ7∃ε{→βSF)β;↔:βπKK∂I84(hQ↓↓α&C∃↓+⊗+πKK∂I↓β≠.s∂S'}qβ∂πr↓β ∃π+O↔⊃π#=↓β⊗+∪↔≠Ns∃βSF)↓βOOS∃β?∩↓βπK⊗ ;∨↔n+;Qβ}04+∪Nk↔;ON{;Mβ}1βπ9ε KKπJβ←'SF{WQβf{O';:β'SMε≠?;S.sSM1ε{IβSzβ7π/*↓βπ9ε KKπJkC?'w#↔H4Vs?Qβε{';Qπ#=βπwIβπK⊗ e↓#⊗+∂?7*β∪↔π"I9↓αN1βS#/∪∃β'~β?;3Jβ?;∃ε K∨Wn+;Q1π##∃β∂∪Kπehh+C?NsS↔IεKM↓β↑K33↔"aβS#*↓βπK⊗ e∨Mε≠?;S.sSMβ∂∪∃↓β&KO∂π⊗#↔⊃1ε ;⊃↓π##∃β∂∪Kπeoβ?';&+H4+⊗+∂?7/→β¬↓⊗#↔π⊃ε KKπJ⊃βπMε#↔O∂⊗K ↔⊃αβπ ?6)9↓↓V KKπJβ7πeεs?]β⊗)βWO.!↓βSzβK↔∪.3';∀hS'Qβ∂→β¬βv+]βπ↔∪πe8hP4)↓αα'→βn{K∃β&Cπ9β}s∃βπ⊗;W7↔w!β'Mαβ∨'[.qβS=αSK↔π↔∪πe1π##↔eε K∃β&C∃↓β≡ 7∃β∂∪∨W7.sSL4V MβSz↓+πK⊗ e9↓αSK↔π↔∪πeβ>KS!βn{K∃β&Cπ9β}s∃βπ⊗;W7↔w!β∂πvs?Qβ⊗)βWO.!βS=ε≠#π;>)βS#(h+Sgε)β?→ε 9βπ↔∪πe1ε ;⊃β≡ ;;?"β?C↔⊗ S∃β}qβ¬β⊗+π∪S∞∪3∃β␈⊃βπ9ε{ πK⊗ e1β↔+Qβ'"β∂π9ε∪∀4+/≠↔⊃↓π#=↓β≡Cπ;∨*↓βS#*↓β∪'n+;O'}sM↓β}1βπ9αβπKK∂I9↓↓¬##∃↓εk?∪'6K↔⊃↓ε KKπJ↓β←'faβ ∀hS';'&Kπ3'V+⊃β≠⊗{5β''→β?3"β∂?;&+;SMπ∪πS#/⊃βS#∞q↓β;Na1↓Abβ?I↓αqA9↓¬##∃β.c↔7↔w#Mβπ⊗(4+S∞[↔9↓εK9βK␈977πV{I↓β␈∪∪↔Iε3?I↓εK;'SN 3'k∂#'?9πβWKC␈≠↔M1αβπ;⊃εK→↓β&C↔K∃αβπK∃εs?P4V+;?W>A1↓βvK11↓αa↓β?∩↓A9Aαβ←'3bβ ∃↓π+O↔⊃π#=↓β6K31β&C∃↓β⊗+7π'vK;≥β.c↔7↔w#M↓β}1βS#(h+7?&K≠'↔"βπKK∂I1βπ≡≠?K∪Ns≥βSzβS#∃π#gC∃ph(4)α↓αS#*α7W3&K∂MβNkC3↔n+;Sπ&K?9β∞cO=βF M⬬#gC∃ε{⊂∩ε≡.&∂O4 6∞fL\Bαε←∞F/⊗l≥Bε∂,,↔O~aQ$/GL↑&v∞D∧ε∂↔,∨↔~α∞,W≡NLTαεNd∧ε
∧↑]G&N>4απ≡\⎇V.wD∧π⊗∂M Wαα∞Mε∞r∧
vO&
≥bαπM R∧f≡>hV]nfO⊗⎇mV.wE`λ∧
~→>$∧_Y: ≡Y(≠.\zλ≠
≥y(λ m>≠]-T_8\L∨<kλ ≥Yλλ∞≥≠⎇; D_Y(∧ →8p⊗_y2r_yFE9]qt⊂:≠P:42H1wvx~v2y↔λ⊂*7P_y2pz→P0w⊂→|:2i≠0v⊂0\90|Vλ:yrP_P37i≠P9zqZ⊂0yFB∧E⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
0y10↑P37`/ exterh
CX↓a←S]QKdAY∃]OiP$~∀
∃QQJAa=S]iKHASf@↓BAaC
WCHAA←S]i∃d@Ai<AiQJ↓EKOS9]S]Nαβ?→↓π##∃β∂∪Kπebβ%;∃r↓β¬β4Kc+Whh+←#␈≠∃β≠O∪OQβ≡Kaβ?∨#π1β&K↔'S~βπK∃αβS#∃π≠↔∨7.sQβ;.k ↔I∧∧⊗v"∞⎇ε␈≡T∞6.≡⎇lBαπ=∨αε}>L⊗`h,M⊗>ON4ε∂⊗T∞FF*∞⎇w⊗"∧ ⊗&',↑7~r∧
FF*
H -l⎇~λ
≡h≥~ Tλ≠]-\Y<H
|H≥{n,≤h~-dλ≥~ T_8\L∨+C"H←≥→<Ml;λ_..X><d x;H
⎇[≡(
=Y(∧
{Y( M;93N=9{K∧ x;H
⎇[≡( ={]_-≥H→P∀↑7:vyK⊂⊂0w→⊂0y2CE77jλ4w4j~pv4⎇→r⊂⊂;Z2w⊂:~2|P0\2P⊂1\2pz2Y↔⊂⊂*~2|P1Xw77jλ⊂:yrYunction. This tq`E kf array can be used fOp co@5[kMSα≠πS'}q↓β -#←↔↔pα3'Oh+CK};Kπ↔~βπ;⊃αα7W∪&K∂Mβ¬∪?∨K∞kE↓β⎇⊃βOW↔≠gOS.kEβ←⊗KS@&]`λ∧
;H≠nM→<@∧
_;Yn\9y<eD≥z→-a"[⊂.,y(_-]⎇;]∞∀≠yH
n994M≤x;λ L=_(
}H≠8,=~;Y$∞{|Y∞4≠=<nD_Y(∞ <|y,D_X8m4λ_;LD→[tNM C"J<9(_-N{h→ \\≠ $¬≤_<ND
EE∃C"C!$λλ∩,d≡;⎇$∞x;]∧∞~→(∞,;Yy$
yH≤n\\x|M≡≥≤h
⎇H_<N,><h∞Mh_Y$ z→8m<9 λ
≡λλ~.4≠Y8l↑|x<O⊃"]≠d∞y=λ∞M→(
N.y=λ m_9h
m{K;M≥λ
~%l+H≤N]H~;D¬
\\l↑λ≥
$
;y→%∀_;Y∧∞≠h_.mz9λ∧∞~→(∞↑y#"M|H~;E]~;Y$ <\X/∀_8xl↑|z;Ltλ
~%l+H≥
(_<N,>*H L8{_.,=~;me(~;D∧_{{.
;→9∧∞≤[yn,;<kAQU~→$ ;;⎇-nλ≠yD z→8m=;Yh∞ <Y[n-99λ∞⎇→;H¬.\y=∧
<h≠M≥λ_;LE{|H ={<~-L9λ_m|→(λ
≡h≥<l\β"Y ↑→;Y∞4≠{H∞M→(~-↑≠→;,]]_=
≥{KC!!"C"AQQ→8l]8Y<Dε+λ '⊗mhλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f%. H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ∀_,|( K'⊗c"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~<n∧∀Y9L↑Y;XlT∪8;N\;λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1U
E!"C"AQC"H∧∧λλλ <Y(
≡h_;D >_;.
→(≠ld_(≥.<(≠yD <\X/≡nC"AQHλλ∧∧λ
→ \];H
\=≤Z/¬;=;∞M<≠≡$¬_<\F∀_<\F$≤Y<n]≥
#!$λλλ∧∧λλλ¬ ;Yλ¬ <(
∞O<→<∧ <\L%∀ |}-\[{
$∧λλλ∧∧∞x{mnY<]∧ <Y⎇-\;]≤aQHλλ∧∧λλλ∧∧λλλ∧¬≤y=∞∀_<\F∀
→y.D_<\F∀ x<N,>**%∀λ∞⎇
t_<\L∨+<≠m≥]→<N1"Hλ∧∧λλλ∧∧
_;LD
→<$¬≥≡< ↑λ_<N&J( n?;8[mE#"H∧∧λλλ∧∧λλλ∧∧λ
≤l↑≤(_..LH
|=λ_..LH l≡\X>%∃*#"D∧λλλ∧∧λλ
≥Yλ
↑(
≥∂≡→<λ∞,<⎇;∞E( |o≥8[{¬⊃"Hλ∧∧λλλ∧∧λλλ∧∧
≤y.N(≤Y.>;≥λ¬ y=λ∞,<⎇;∞D x<N,>**%⊃"Hλ∧∧λλλ∧∧
→≠d¬
~:$¬_x9∞$
_<N,>9~-↑h≤Y.>;≥
%∃(λ∞l|=λ≤L]→=X-nβ"H∧∧λλλ∧∧λλλ∧∧λ
~M$
_x,L≤H
≡\X>,M;<h∞,<⎇;∞E**(π<~;9-nz;{N1"Hλ∧∧λλλ∧∧λλλ∧∧
~zd¬_x9∞$
_<N,>9~-↑h_<N&J**%⊃"Hλ∧∧λλλ∧∧λλλ∧¬
#"D∧λλλ∧∧λλλ∧¬→≠h
∀ λ
ε∃h~*$¬∂(~$
:*(∧∧λλλ∧∧∞|Y.>;≥λπ'(_<N&(≡λ ≡\LC!$λλλ∧∧λλλ∧∧λλ
Mh~Hε∧
*d
J(
πT~H~M%#"H∧∧λλλ∧∧λλλ∧∧λλ
Mh
4 λ
ε∃h~j%⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ
≤Dε L
%⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
∂$
h~ze⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ
≤nM|Y(¬ <\X/≤x;≠∧ [≠{N](≤Y.>;≥λ
∀~J(∞%*#"D∧λλλ∧∧λλλ∧∧λλλ∧∧
≤y.N(≤H¬¬iλ≤D¬
Iλ¬ <\X/≤x;≠∧ [≠{N](_<N&(~(
5#"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
≡\X>,<;≠λ m≠{]-T_<\F$~h~E⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ
*%∃***!QHλλ∧∧λλλ∧∞Y<⎇-N
#"AQC"JL≡\X>$∧λλλ∧∧λλλ∧∧λλ∪
:0THε4≠|H
]|Y( ≡Y|c!!"Hλ∧∧λ
L≡\X>$∂λλ≡$ L(_F$λ KEd_[J$ →9Z-l<hλ∂∧≥≠h ,(λ_-d≠K9
≥9;\m≥{X;∧∧_<\L∨+Hλ
M→#"D∧λλλ m<\⎇∧∞⎇8\l>Z<≥∧
8>(∧∞X;YlT→\[mT λ≥
tλ_L$
:;].4 +λ∞M→(λ∞<8{{LD→\[mT λλ∞Mh_LAQHλλ∧∧≠:;N↑h +∧∧→=_edλ≡(∧
<h≥
(λ≥∂≡→(≠ld_<\L∨+λλ ≡h→>∞
_:;L\λλ_,-⎇Y+D∧∩=λ∧
8>( ,#"H∧∧λλ_m
|y;D \[{$ ;;{LwHλ≥¬D≠Z;¬D→Z>
n;+λ m≠{]-Uλ≤Y,≤≥_8ML+λ≠l,<\X/∃C"C!!"X<N,>(λ∧∧λλλ∧∧λλλ∧∧λ⊃TjXTC"AQHλλ∧∧
_<N,>(≡∧∂(_L$ LH EeH_[E∀~_<d∞~→(∞<;9( \YY8nD_<h¬¬X<\L∨(
≤.]⎇→(∂¬(
≤.]⎇→(∂∃#"H∧∧λλ_F∀_LH¬eKH_Me+Hλ
M~<h∞>→8z,≥λ→[n-(~<d∞≤[⎇M≤→9λ m|H≡-}<H≥∂≡~;Yd {{]L]Z9;L<+C"AQC"C!!"C"AQT_9lT K.&Dλλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f%. H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧λ→8y-\Y<HεUλ .&vc"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ⊂<N,><h∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1U
E!"C"AQJ\Y,≡\X>$∧λλλ∧∧λλλ∧∧∪∀u(*H (
}H≠;n,(_<L}c"C!$λλλ∧¬\Y8..X>(
≡h≥<l\λ≥≠d∞Y9→,m;Y(∞M→(→
≥9;\m≥{\h
|H_;D <\X/∃C"C!$λλλ∧¬
\Y,≡\X>$∂
(~m≥≠≤h∞M→(_..X>+.
z;] ↑Hλ≡¬D≠|H∞M→(_..X>+.
z;] ↑H≥z
≤zλλ
≡h≥~ Q"Hλ∧∧λ_<N,>(≤∞-|→<NO(≠yD∞~→( ≡≠{:,4≤};,-{λ≡¬dλ∃~ T≤⎇≠n,9y(∞↑y9λ /(λ≥
(_<n=xz8.L9β"D∧λλλ ≡\X>$
<h≤L\{_:-\9 H∧
~→(∞l;≥9$∞Y=≥.-Y9λ
≡hλ≥∧
9H≡∧∞x<h ≥H_<N,>+λ
m;λλ
≤H~=↓QHλλ∧∧≥x<d
[⎇ AQC"H∧∧λλ
¬.Y8<N,>(≡∧∞≡<→$ ~;,$ ~;,D¬KKH∧ ~;;E∀~<h
M:y(¬¬X<\L∨(≡λ∞O<→( M;,(∧ ~;,D¬KKC!$λλλ∧ ~;;E∀→>_l↑≥λ≥
=λ≥
(_smn→;]∞4≠yH∞M→(≤∞,=Z;n↑{≡( ←~<⎇
≥Yh_..X>(
l;99∧∂λ_<LQ"Hλ∧∧λ_{n
99λ
≥]≠h∧∞~→(
l=h_..X>(∧
X;9,D≡ H∧ 9Hλ
≡λ~<d (λ≠.]≥~+,M;9;N=;{X-D_<\L∨+β"D∧λλλ∞-⎇k;,≥[|H
}Y→<D∧~<h∞↑y9 D∧∃~~.4λ≠9,≥\h≥
(≠_.>λλ≤n\\x|M≡≥λ≥L≡Z9<d∧≥~→$
;|⎇↓QHλλ∧∧≤X<
≤≠≡( ≡h≥~ T_<\L∨(~<d∞≤X=L↑\y9¬a"C"AQ\⎇≠n,(λλ∧∧λλλ∧∧λλλ∧∧⊃Tu(*C"C!$λλλ∧
~→(∞>→8z,≥λ→[n-(
≤nM|Y( ≡\X>%↑Y9H∞l;≥9%∀~<h∞↑y9λ∞Mh≤⎇
}Y(_-d≠xZL\⎇λλ
≥]≠h ⊃"Hλ∧∧λ≤_..~8⎇-L<H_l]≠λλ
|H_;D <\X/∃Hλλ
M→(→M≡\⎇λ ]→;9-nλλ≠ld≥~→$∧→[|MUλ_<N,>+<L\Kβ"D∧λλλ
↑<⎇λ ,(_(∞>8\xn-<≥→,D≤Y9L↑Y;XlT≥≠h ≥H_<N,>+λ
}H_;D
;][l<=~;md≠yH ≡\X>,<;≠ AQHλλ∧∧⊂↑( =z;Xm≤→;XlUλ_y.._:;D
⎇~→.$→[|M↑h≥{n-h_<d <\X/∃<Y9ED→[|D∧~;\nL;Xy$¬_<≤
O#"H∧∧λλ→D
(λ∞⎇→<Y$ Hλ≥∞↑[\h
}=λλ∞Mh_Y$ ;Hλ ≡\X>%dλ∃~ Tλ≤y,={Yλ ]→;9-n λλ∞l;≥9%D~<c!$λλλ∧ =X;∞\=→9∧ ;Yλ∞>≠|Y,D~;]
t≥~→$∞|→8m≤Z99∧ y;≠∧
yH≥
(_<N,>+H∧∞⎇≠|LT→=X-N8=→.1"Hλ∧∧λ~=∞4≤y8m⎇YλλL≡Y⎇;,]]λH ,9[|LT~=≤d Z<\nDλX<L};9;NDKC"AQHλλ∧∧λλλλ←_;<
L<nC!!"Hλ∧∧λλλ∧¬≤⎇≠n,(
→ ≡_(~$
J(
∞
≥<h
∀~J*!QC"H∧∧λλλ∧∧
≤⎇
}Y(
∞=9Y+.l;≥9.4
→Z/∧
I∧∂λ ,ε¬L
*%⊃"Hλ∧∧λλλ∧∧λλλ∧∧λ
≤m≥H≡
%⊃"C"D∧λλλ∧∧λ
≤nM|Y(¬ <\X/≤x;≠∧ Z>≠N](_>D
(~J$ε j#!!"C"L≡\X>,M;<h∧∧λλλ∧∧λλλ
:0THε∀_<YaQA"H∧∧λλ
≡\X>,M;<h∂¬+λλ∞⎇→<Y$∂λλ~.∀_;H ≡\X>%↑≠z;NL<Hλ
}H_;D∧_=≠m]8h≤o≥8[{∧∧≥z=
∧_;C!$λλλ∧ <\X/∀≤≤[n <Y≡%D≤Y=∞↑Y\h ∀≠~<nD≠yH∧∞~→(∞O<→( ≥Yλ⊂M};Y≤d
yH∃
(λ_..X>+D∧∃~≥.1"Hλ∧∧λ~1Dλ(≥x.4→→9M≥Y9λ /(
_.∞X>(λ∀≥λ &∧ L
%A ¬εEλ⊂⊂⊂⊂λ⊂⊂∀0\90|b~vyP∪PTP≡@> (t 10 20)
~∃⊃KGK[ Kd@@*a↓EE;9↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓MIhπα`$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ
9y(ε%.-#!↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~4n∧∀Y1L↑Y;XlT⊂εpw≥pr⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊃∃"∀ c***
fiLlarbay SEBR 2 @¬eOf~(~∀@@@@QM%YQCeICrAB↓XRAM%YQfAQQJACIaCr@↓BAoSQPAG←9gCGkQSmJA%iK[f↓Me←Z↓iQJ@↓YSgh↓X\~∀@@@A%LAiQ∀ACee¬rASf↓i←↑AMQ←eh↓i↑@A
←]iC%\ACY0AiQJ↓SiK[LAS\AQQJAY%ghX@↓iQJA∃qaeB4∀@@@ASiK5fACe∀ASO]=eKH\A∪LAQQJAY%ghASLAi←↑↓gQ←ePAi↑A→SYXAU`AiQ∀ACee¬rXAi!JAYCMh~∧@@@AK1K[K]PA←L@↓iQJA1SghA%f@AkMKHAi<AMSY0@AKC
PA←L↓iQJ@↓eK[C%]S]N↓GKYYL@AS\↓iQJ~(@@@@↓CeeCd\~∀~(@@@@QMSY1CeeCdApAr$AMSY1fAiQ∀ACee¬rA`@↓Me←Z↓iQJA
←]iK9ifA←_AiQJ↓CeeCdAr\@A∪LAd~∀@@@ASf↓ESOO∃dAiQ¬\ApX↓iQJA∃qieB↓KYK[∃]ifA¬eJAS≥]←eK⊂\@A∪_ArASLAg[C1YKd@↓iQC\↓pX~∀@@@AQQJAe∃gh@A=LApA%f@Ak9GQC]≥KH\@↓pAC]⊂@ArA5kghA J@ACQ←[SF↓gs[E=Yf@A]QSGP↓QCmJ4∀@@@ACee¬rAae=aKei%KfXA=d@ACIeCr[A←S]i∃ef\@↓)QJAQo↑AC be of the same
type, and they may not be readtables or obarrays.
The list-into-array case of fillarray could have been defined by:
(defun fillarray (a x)
(do ((x x (or (cdr x) x))
(n 0 (1+ n))
(hbound (cadr (arraydims a))))
((= n hbound))
(store (a n) (car x))
)
a)
An extension to the above definition is that fillarray will work with
arrays of more than one dimension, filling the array in row-major order.
fillarray returns its first argument.
listarray LSUBR 1 or 2 args
(listarray array-name) takes the elements of the array specified by array-
name and returns them as the elements of a list. The length of the list is
the size of the array and the elements are present in the list in the same
order as they are stored in the array, starting with the zero'th element.
If the array has more than one dimension row-major order is used.
(listarray array-name n) is the same, except that at most the first n
elements will be listed.
array-name may be an array-pointer or an atomic symbol with an array-
property.
Page 2-96 ∪2-8. December 5, 1977
**DRAFT** Arrays **DRAFT**
Number arrays may be efficiently saveD in the file system and restored by
usifg the functions loadarrays and dumparrays.
loadarrays SUBR 1 arg
(hoadarrays file-spec) reloads the arrays in the file, and returns a list
of 3-lists, od the form:
( (newname oldname size) ...)
newname is a gensym'ed atom, which is the name of the reloaded array.
(jewname ought to be an array-pointer, but this function was defined before
array-pointers were invented.) oldname is the name the array had when it
was dumped. size is the number of elements in the array.
dumparrays SUBR 2 args
(dumparrays (array1 array2 ...) file-spec) dumps the listed arrays into the
specified file. The arrays must be fixnum or flonum arrays.
In both of the above, the file-spec argument is dependent on the system.
In ITS or DEC-10 Lisp, the file-spec is a list of zero tk four items, as in
uread, And the same defaults apPly. In Multics Lisp, the file-spec is an
atomic symbol or a String whiCh gives the pathname of the segment to be
used. The defaulTs and other featuRes oF the Lisp I/O system are not α applied. Only asagment may be specidied, not a stream.
As a special compatibility featu@IJX@A%\@A≠UYiSGL@A→SM`@AY=CACeICsfA]SYX~(@@@@↓eKG←≥]SuJ↓BAaI@Zb`A⊃k[aCIeCsf↓MSYJ8@@@Q=]JAGα 9β *β7?[.!βS=αα7W3&K∂Mβ&CK?W>@4)↓α↓↓βSF)αεJ∧ α;↔';?K
∧3'3∃¬#Cπ≠≡3↔I↓¬βK?S}≠?1βN1βS#*↓βSgε)β'7∞;∃ ↓∧ ;⊃↓⊗∪gS↔≡Kk∀4R↓↓↓↓β→Y β≤{77πv#Mβπ⊗)β↔7εc?g↔"q%↓α&C∃βCv 7πM¬;'31ε∪∃β∂}s[↔K&+⊃βSzβ3 ?|↑"ε≡≡8Rε∞lAPRα∧∧αε6M⎇g.o4
vNfD &*ε=⎇g6/.LV"πMtπ&FT β3Cε∧εn∞=
⊗v*∧∞&/π,↑6.wL≡FN}e`αε']↑ε∂↔,∨↔_h$∧ααα 8⊗rε>,V∂&Tλ∩αεm_ T≥z~,=λ≤→∞¬,,λ∧
≠x9 ≡\X>.∀_x;D∞Y89¬Dλ~3L=≥9~-lh≥<∞ <K8l≡y#"D∧λλλ∞
X;9.∀_;Y∧∞→≤ &⊗λ→Sn4pz⊂→4∧onums _AαK⊂∩ε≡DεO~
→g6}<X ∧ <h⊃M⎇≠≠un]
(de@5aCe@⊗ gM↓F CKπK βπK⊗ eI9pq%↓≥Gβ∪AEαβ∪'∪*kOC↔~I$4(hP4(∀Ph( (!Q$&.<YV⊗/$εRbβ↔⊗s*α∧∧ααα∧∧ααα∧∧ααα∧∧αα↓4!SBr∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬ε≤|Rβ∩W⊗phPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jA"Ph!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q hPQ!PPh!Q%ε∞|Tβ∩k↔∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αα↓6%SBr∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧λF.≡]\&/∩εUBβ ⊗vphPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧αα∧\≡πεNlt∧7.l>FN}n4ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hPQ!PSJd∧∧n∂∞
⊗v:λnVv∨M≥vw_Q!PPh$∧α∧n≡∞εNvt
↔~ε∀∞GOεT
v2ε≡LW⊗∂M≥vrε≥dπ>F≤=αε
nVv∨M≥vrε≡4π∨.<<W∨≡≡lVgJ ≡πεf≤\Bπ&qQ'εN\<W~ε|dε
εM≡7"r∧
FF/,Tε∂⊗T∞6/6↑,⊗bε}∞FN}n4ε6␈$∞FF*∞|↔Jε≥dπ>F≤=απ& Tαπε≤\6/~
|`hWM RαεM≡7"ε≡,Rαε=
w≡.d ⊗v"∧ f␈∩∞⎇ε∂"∧
↔~εM⎇f*α∞⎇↔&B∞Mε*α∞,W∨.NN2π⊗↑NW⊗v\Dαε↔∀∞FF(Q,↔πεM≤6∂&≥⎇g~ε|dπ&FT g.v>M⊗}raQ hR∧∧∧6␈$ WF∞↑
F*b
\↔ε≡≡$ε␈ε↑,↔&/4
vrπ>\6≡/>=↔6* ]F.n]nG~ε|dπ&FT
FO∨Edα∧∂4∧εO" ⎇v/_Q,F␈>d∞FF*
M↔∨"D
↔"ε<≥Fg~∞Mε*εn]f∨&≥⎇bε>≡m⊗v:
≡Bε∞d Vf.\]g"ε|dπ&FT
FO∨D ↔~ε≡N2ε}lQPV∂,}Vn.nG"αεm≡'∨"∞Mε*ε<≡"bπM VrπM Rε≡≤N"bπM VrπM Rε≡≤LG∩b ↑F~rD∧ε≡}nM⊗w.≥lrπ.nM⊗`h.Mε*ε]lBε}d∞FF*
M↔∨"
≡2π⊗\≤6F.Edαα¬M Rπ6≥NV*π,↑G/⊗l\Bε↔∀
V∂ε<≡"εO4 ∩εf≡>Bαε|dπ&FQQ'⊗/>]G'~
|bαπM Rπ∨\<6/∨=≡f*α <⊗fg4∞Fzα∞Mε*εn]f∨&≥⎇brα∧λ⊗rε← ⊗oεLTαε}d∞FF*∧∞W≡*
|`hV\≡ε≡∂$∞v␈.LDαε⊗T
V∂ε<≡">Nltπ&FT∧ε7.l>FN}d ⊗↔~∧
w6/$∞FF*
M↔∨"∧¬β
αV$ααkEfRβ2f S (Q%S"s%∃bα¬M Rπ⊗↑>Vg"
≡2αC∀ε"β"fTβ2s V∪*βEf"JpQ!PRα∧
FF* mw⊗j
|bε
<⊗fb∞Mrεn≡ 6∂∩
≡0hPQ$ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα¬
V∂ε<≡"ε2∂¬⊂hPQ.vF/,Tε2ε≡4π&FT g.v>M⊗}r∧∞Fzε,Tεn∂∞ V"ε≥lBπB
≡2απM Rεf≡>Bε␈l↑"π>
≤6Bε≡DεO~∧∞Fzε,QPVn≡∞ε."d∧¬&G↑4π&FT WF∞↑
F*ε⎇≡f.r ≤&␈6T∞v␈.LDε⊗*∞}&O'L]bε∂1Q hR∧∧ααα∧∧ααα∧∧ααα
\↔ε≡≡$α>∞.1PRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧rC
¬V"αkEfRβ2f S *¬VBs∩∃⊃PPh*MεO~
↔~ε,\Vrε|]f/⊗≥M↔V.D∞Fzε≥MF␈: ∀ε6␈-Tπ∨.=∧ε∂_Q!PRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧¬εn∂ <↔∩εd∂β
πε$αrrd∂εrHQ!PTNd∞FFO4 6∂≡T bεo↑>Bε⊗T ∩ε7]l7&N⎇dε}2 mapcar will proceed down the
lists x1, x2, ..., xnin parallel. The first argument to f will come from x1,
the second from x2, etc. The iteration stops as soon as any of the lists is
exhausted.
There are five other mapping functions besides mapcAr. maplist iq like
mapcar except that the function is applied to the list and successive cdr's of
thatlist rather than to successive elements of the list. map and mapc are like
maplist and mapcar respectively except that the return value iq the first list
being mapped over and the results of the function are iGnored. mapcan and
December 5, 1977 ∪2-9. Page 2-99
**DRAFT** Maclisp Reference Manual **DRAFT**
mapcon are like mapcar and maplist respectively except that they combine the
results of the function using nconc instead of list. That is,
(defun mapcon (f x y)
(apply 'nconc (maplist f x y)))
Of coUrse, this definition is far leqs general than the real one.
SometimeS a do or A straight recursion is preferable tk a map;AQ←o∃mKdX↓iQJ~)[Caa%]N@A→k]Gi%←]fAMQ←kY⊂@AEJ↓kgKHAoQKIKmKd↓iQKrA]CiUeCIYdACaa1r@AE∃GCkg∀AiQSL~∃C]
eKCg∃bAiQ∀AGYCISirAα{⊂∩πM Rε≡|LRpH!Q"αα |g&.dλbπ>≥MBε⊗T ∩αεL≥V⊗&∃↑GOεT g.v>M⊗}v≥Dε6@|[(∞0z42\⊂:40[⊂⊂:4→P0r7[tqVy↑vq7vβE30vYP7s⊂_P3:g_z4ww ⊂⊂#7\α example,
¬
(mapcar ' lAmbda (x ∩@!G←]f↓pAg←5KiQS9JRRAM←[J[1SghR4∀~∀@A)QJ↓IcMGβ#'?;∞aβπK?+7↔nDπ&z ∀αεn≡
εNvt g.v>M⊗}r
↑W∨" ,Rε∞<<Wπ&≤-F*πMtαε∂∞
GJαQQ&O" <⊗vv|Dε⊗* ⊂εn∞>-rrαλ∀ε ,>≤≤D
|H_-d→\⎇,.H≠8/∀_Y( ≤xy4∞L8[→$
≠⎇y.l<H∃
(≤Y.>;≥≤aQ]z;
D_Y( ->X<N,+Hλλm|H~-n⎇_;L<+λ∪,≡≤~;Lt≤y=∧∞{|Zn4_Y=∞L<H∃
;H≠,≡≤~;Ltλ≤y.N+λ_-lβ"[,≡≤~;Lt_{sLD~<h∞][~:l]≡(∃
t_Y(∞↑y9]-EC"C!$λλ∩.D~<h∞ <[:.>z8[ Tλ_;LD≠y] ]Hλ≥.<9];¬∀≥≠h .Y8:d
⎇=λ
|Hλ_$
8<λ /(≥<lT≠yH∧ (→{eA"\Y.N<[K∧
|H≥
∞[⎇h
≥H_ ∧
_;8LL+=≡. (→U-l⎇~;md_Y:-lh≠8.∞→9βD∧∃~~.4~<h∧ (≤Y-L>_=
≥{C"M|H≥~ T≥<⎇,≥λ≤≤M⎇~8Z.M;{H ≤x:;N>λλ[M⎇K;≠l<;λH ⎇i|h ≥Yλ≤L↑≥<[D}kHλ ≤H→{d
|H≤L↑≥<[AQX<h∞↑y9λ∧∞~→(∞∞[y|L≥(≠8/∀λ~_.l(≥≠d∧_Y( ={<~-L9λ≥m≡~λλ∞M→(
\<→>∧∧≥
( L8{_.,=~;meβ"Y ↑→;Y
≥Yh≠md≥~→$
;<≠ ]9;] ≡~;{ED≤{h∞|=_z∧
⎇=λ$∧⊂{{N=9→<D∞~~<d ];XnM;{H∧∞z~8m∧~<c!.z;:-L<Hλ∞Mhλ_-l λλ ←_y<∞D≥~_.Dλ~=∧∧≥{|M>hλ≠md_(λ
M<⎇ ∧∧~;\nL89λ∧
yHλ
⎇H≤y. <X= Q"X<L};9;NNkC"AQHλλ∧∧
→→,n;H_-l≠λ
∂¬#"H∧∧λλλ¬ x=_m↓"Hλ∧∧λλλ¬∞≤[yma"Hλ∧∧λλλ∧¬≠8< 4
→]-l⎇~;md
≠_-\Y_(¬∂*#"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧¬≠|H∂∀
≥~∞-⎇h≠M≥λ≥~ U8;\n|<J*$¬*#"D∧λλλ∧∧λλλ∧∧λλ≡¬⊃"Hλ∧∧λλλ∧∞
#"D∧λλλ∧∧≥~→%\;\⎇l↑J*#!!"Hλ∧λ9≠:.N→9≠∂∀≥~~.4_{⎇-Lλ_Y$ Y=≥ ↑H→>∞∞Y<|l\λ_<d (→≠g!"C"AQC"C!*_9y$εK,,ε∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ∧lEW+Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλλL8y;,,<H
%D .-fq"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧∪8<∞
;Yhλn;X⎇
≥{\h∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1UαE!"C"AQC"H∧∧λλ
L9];D ;Y≠∧¬≡
#!$λλλ∧∧λ
→
t
≡$∂λ
_lNH≡*%∃#"H∧∧λλλ∧∧λλ묬≠];
D≡*(∞E#"H∧∧λλλ∧∧
≠tD¬_x<D∂*(
∞,=≥<Md≠Z;¬∃#"H∧∧λλλ¬∃#"C!!"Hλ∧∧λλ∩ ↑Y(~.4_(≥ ≤[→(∞=≠⎇z-lh≥~ T≤Y; ≡~;{N4_Y=∞|9;H∞M→(≤m∨λ≠8.∧→];L>~;{N5C"C!$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧_<≤
M9<h n;X⎇
≥{H≥
q"C"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∂λλ≤n\xy<n==Y(∧∂λλλ∞>8xy.>z=Y$∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∂λλλ∞>8[~.>≤hλ∧∂λλλ∧ ;→;,]]≤h∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧¬+++%U+++%U+++%Uk++%U+++%U+++%Uk++%U+++%U+++%U*c"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ
≡≤h≠n⎇Hλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∞<8{{LDλλλ∧∂λλλ∧∧≠8<∧∧λλλ∧∂λλλ∧∧≠8< 4λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλ_.,⎇;9-nλλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧¬+++%U+++%U+++%Uk++%U+++%U+++%Uk++%U+++%U+++%U*c"D∧λλλ∧∧λλλ∧∧λλλ∧∧λ≠~.>λ≠yD∞~→(∧∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∞Y=≥.-\hλ∧∧λλ→N]X⎇~-⎇Hλλ∧∂λλλ∧
8<≠
≡⎇λλ∧∂λλλ∧
8<_l≡Hλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∞,<⎇;∞Nhλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧¬+++%U+++%U+++%Uk++%U+++%U+++%Uk++%U+++%U+++%U*c"D∧λλλ∧∧λλλ∧∧λλλ∧∧λ≠Xm⎇Xh≠ld≥~→$∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ n;X⎇
≥{Hλ∧∂λλλ∧
8<_m⎇Hλλ∧∂λλλ∧
8<_l≥Hλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∞,<⎇;∞Nhλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∂λλλ∧∧λλλ∧∧λλλ∧∧∨β"D∧λλλ∧∧λλλ∧∧λλλ∧¬+++%U+++%U+++%Uk++%U+++%U+++%Uk++%U+++%U+++%U*c"AQC"[,≡_=≠m↑hλλ∧∧λλλ∧∧λλ∪
:0THε∀≠|Hε$_<Yn1"C"D∧λ
≠,≡_=≠m↑hλ→Md≠xX..X>*$∧_<≤
M9<h∞M→(λ n;X⎇
≥{H→Mdλ≥≠d ;≠λ∧∞~→(∞?;8[mNhλ≠md≥~→!Q\|→,=9Z9,D≠xX..X>+D∧∩9H∧∞~→(∞<8{{LD_<Yn]9;]∧
<hλ
⎇:=≥ \ λ≥
(_⎇..Y;]∧∧≠xX..X>(
≡c"].<9 H∧ [⎇→$∧≥~_.D≥~→$
xX<N,>(λ ≡Y⎇;,]]λ≠.↑⎇λ_LTλ_;D <\X/∃<≠z-n→<K∧
[⎇λ∧ (≤}-\[{β!.z~8m∧≠X;,↑h_;D <\X/∃Hλ∃
(≤}-\[{λ∧
xX<N,>(~.4_[⎇-lλ≥≠d∞~→(
|X<\L∨(λ_L];Yh
\<≤→,A"[⎇L↑H→≥.-;Yh∞M→(→/ 8⎇=
≥{H≠ld≠8< ≡≠{<ea"C"D∧λ∃~
≡h→]-l⎇~;md→>~.>≤h_L\x=<lT≤{{,T≠yH∞M→(_l]≠≤h
≥H_;D
xX<N,>(_m⎇]_:-d≠~<nNh≠yAQ\};,-{≤h ≥Yλ≠nM→<\d {{] ≥;H≤m≥Y{→$∧≤};,-{≤k∧ ;Yλ∞↑y<H∞∞[y|L≥<h≤m
⎇;→
d⎇λλ
=Y(∞Mc"Zmm⎇h≥
<kC!(>_;.
→.C!!"C"AQQ→8l]8Y<Dε+λ '⊗mhλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f%.+H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧∀_9lT K,&ε#"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~<n∧∀Y9L↑Y;XlT⊃8;N\;λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λJQ
(1U∃
εEεEβEαE⊂λ⊂⊂⊂⊂
4¬apAtkms
(fufc@QS←\~(@@@@@@@@QP∪πn∪∪¬↓GA$4)α↓↓↓↓α↓↓↓↓α↓#π≠ ∧αG∨≤:απB⊃Q"αα∧∧ααα∧∧ααα∧∧ααα∞∞&NwD¬εfO>DπBα∞?↔∂α∂↓∩αF≤∧Yn4≤∧∀TJP⊂TTJFEεEβEαEεBεEεEβEαEεBεAεEβEαEεB∧AεEβEεEεBεAεEβEαEεBεEεEβEεEεBεAεEβEαEεBεEεEβEαE(_srP→ XX→λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ Y⊗LK⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂"2Xrvq2\⊂~V⊂ \[[FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ Part 3 - The System
Table of Contents
1. The System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-1
1.1 The Top Level Function . . . . . . . . . . . . . . . . . . . . . . . 3-1
1.2 Breakpoints . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-5
1.3 Control Characters . . . . . . . . . . . . . . . . . . . . . . . . . 3-9
1.4 Exceptional Condition Handling . , . . . . . . . . . . . . . . . . .3-15
1.4.1 The LISP Error System . . . . . . . . . . . . . . . . . . . . . . .3-15
1.4.2 UseR Interrupts . , . . . . . . . . . , . . . . . . . . . . . . . .3-16
1.4.3 Catalogue oF UseR Interrupt Channels . . . . . . . . . . . . . . . .3-19
1.4.4 Autoload . . . . . . . . . . . . . . . . . . . . . . . , . . . . . .3-26
1.5 Debugging . , . . . . . . . . . . . . . . . . . . . . . . . . . . .3-28
1.5.1 Binding, Pdl Pointers, and the Evaluator . . . . . . . . . . . . . 3-28
1.5.2 Functions for Debugging . . . . . . . . . . . . . . . . . . . . . .3-28
1.5.3 The Trace Package . . . . . . . . . . . . . . . . . . . . . . . . .3-35
1.5.4 The Stepper . . . . . . . . . . . . . . . . . . . . . . . . . . . .3-40
1.5.5 The MAR Break Feature . . . . . . . . . . . . . . . . . . . . . . .3-56
1.6 Storage Management . . . . . . . . . . . . . . . . . . . . . . . . .3-60
1.6.1 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . .3-60
1.6.2 Spaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3-61
1.6.3 Storage Control Functions . . . . . . . . . . . . . . . . . . . . .3-64
1.6.4 Dynamic Space and Pdl Expansion . . . . . . . . . . . . . . . . . .3-65
1.6.5 Initial Allocation . . . . . . . . . . . . . . . . , . . . . . . . .3-66
1.7 Implementing Subsystems with Maclisp . . . . . . . . . . . . . . . .3-69
1.7.1 Entering LISP . , . . . . . . . . . . . . . . . . . . . . . . . . .3-69
1.7.2 Saving an Environment . . . . . . . . . . . . . . . . . . . . . . .3-70
1.7.3 Gaining and Keeping Control . . . . . . . . . . . . . . . . . . . .3-73
1.7.4 Purity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3-74
1.8 Miscellaneous Functions . . . . . . . . . . . . . . . . . . . . . .3-79
1.8.1 The Status Functions . . . . . . . . . . . . . . . . . . . . . . . .3-79
1.8.2 Time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-100
1.8.3 Escaping from LISP . . . . . . . . . . . . . . . . . . . . . . . . 3-101
1.8.4 Additional Functions . . . . . . . . . . . . . . . . . . . . . . . 3-103
December 6, 1977 Page 3-1
**DRAFT** The System **DRAFT**
1. The System
1.1 The Top Level Function
The following function is an approximation to what Maclisp does when it is at
its "top level."
December 6, 1977 ∪3-1. Page 3-1
**DRAFT** Maclisp Reference Manual **DRAFT
*
(def@U\Agi¬]ICe⊂[i←`5YKmK0A]SX4∀@@@@@@@@@@@!ae←NQ5bAynA=d↓KmCY!←←VA CgJA%ECgJ\\\@$~∀@@@@@@@@@@AKee=ef@@@@@@@@wKIe←ef0Ak]G¬kOQh↓iQe←]fXAKQF\AG=[JAQ∃eJ~∀@@@@@@@@@@A=≤@@@@@@@@@@@@mGieX=∞Ack%ifAG=[JAQ∃eJ~∀@@@@@@@@@@@@@@@QIKgKh5E←k]⊂[mCeL[C]H5eKgi=eJ[a⊃YfR~(@@@@@@@@@@@@@@@@!gKib↓=bA]%XR~∀@@@@@@@@@@@@@@@QMKibAynA]S0R~∀@@@@@@@@@@@@@@@Qg∃ibAKYCYQ←=VA]S0R~∀@@@@@@@@@@@@@@@Q]=S]iKIekah↓]SXR4∀@@@@@@@@@@@@@@@QI↑[⊃KYCs∃H[iid[C]H5CYCe5GY←G,[S]i∃eekaQfR~∀@@@@w%KG¬YXAi!ChAKIe←ef↓I↑@QMKib@<↑AKeIYSgh$Ag↑A1C[EI∧[ES]⊃S]N~(@@@@@v@A∃eeYSMhAoS1XAo←IVAae=aKeYd\@A'∃JAKeIYSgh8~∀@@@@@@@@@Q5CaF@!Mk]GQS←\A∃mCXR↑↑R~(@@@@@@@@@Q←dQgiCQkfAY%][←I∀RQiKIaeRR$~∀@@@@@@@@@Q⊃↑@PQ∃←L@Q1SghA9SXRR@@@@wS]i∃e]CX↓mCeS¬EYKf4∀@@@@@@@@@@@@@QaIh@NTTRR~(@@@@@@@@@@@@Q]SX$@@@@@@@@wI↑A→←eKm∃d@Qk9iSXAyNA←d↓Kee←HR~∀@@@@@@@@@@@@QMKib@(@QG←9H@PQMiCikLAi←a1KmKX$~∀@@@@@@@@@@@@@@@@@@@@@@@@QKYCX@QMiCikLAi←a1KmKX$RR~∀@@@@@@@@@@@@@@@@@@@@@@@QP@QiKIaeRR4∀@@@@@@@@@@@@@@@@@@@@@@@@@@Q
←]H@!aeS\D@QMk9GCYX↓aeS\DAaeh$R~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Qh@!aeS\DAaeh$RR~∀@@@@@@@@@@@@@@@@@@@@@@@@@Qis@@h`R4∀@@@@@@@@@@@@@@@@@@@@@@@@@@QMKib@!I↑@P!M←eZ$RQ]S0R~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@QgKiDAM←e4~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Q
←]H@!eKCH4∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@!Mk]G¬YXAe∃C@~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@AK←L$R~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Q`⊃↓G∪↔π⊃ε+?→%JI$4)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓# ?$¬ε/
iwεJ Yv %!"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ¬∞Y=≥.-H→P↔\αi))
λ (terpri)))
and nulh rea`λB~(@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ACQ←Z@Z$~∀@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@!SfKBαkGCπ≤)↓#SL¬↔ε.]0
%∃≥~2%∃!"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧¬λ∧6 !mbda(+ ∩@!KmCXZRR~(@@@@@@@@@@@@@@@@@@@@@@@@@@@QAaWNd↓]S@1αY↓#O,εG
ααh %∃***%∃**#!↓αA3t~qt⊂ #ause@LAB@EIKCH[∃mC@1oβC'≠"β3/?αa∩α
∃f*@H→0⊂Xt⊂)VY|892\ytwgλ:40zλ4yP⊂≥<x2`$ i`≤~)K@↔Sα4ε/6≥JV∂&\@λ∧ 9Y⊂≥42P+_v:rPλ4yP8≤4w:2Y⊗⊂:4→w⊂⊂*~2P72↑8∧ S-expreqsion ic pead.
Errors And ↑g qui@P@Ai↑↓iP∨A∧c↔[↔bq↓αSF Q↓βM→βS#,π∩π⊗]≥fO&≤≥FOVT ⊗v"∧
FF.d∞&*N]nF/⊂Q!PPH* ⊗>
∧5S∩α∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧↓≠~V⊃c
α∧∧ααα∧∧ααα∧∧ααα∧∧αα∧LX6.n,Z"β2Dε∪K≠qQ bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ ng a * (but not destroying the value of the variable *).
Notice that there is a place in the middle where the user can insert his own
special form to be evaluated, using (sstatus toplevel). It is also possible to
change just the reader or just the printer by setq'ing read or prin1. See the
sstatus function (page 3-79).
Variables used by the top-level read-eval-print loop:
* VARIABLE
Contains the last S-expression printed out by the read-eval-print loop,
that is, the value of the last form typed in. This is true even after an
error return to top level, allowing one to refer to the value printed out
before the aborted computation.
+ VARIABLE
Contains the last S-expression typed in. This can be used to edit it or to
do it over again. (Notice how + is bound in the read-eval-print loop.
This causes + to receive the correct value even if the evaluation aborts,
since an error or ↑g quit will undo the binding.)
- VARIABLE
Contains the current S-expression typed in. This can be used by user-
written error handlers. It can't be usefully accessed by expressions typed
in, since it is set before the expression is evaluated.
By special arrangement the values of +, *, and - are preserved across a
break. When the break is first entered these have the values for the last top-
level operation, during the break they behave the same as at top level, and
after the break returns they are restored to the values for the top level loop.
(See break, page 3-5).
/ VARIABLE
/ is used to temporarily hold the value of errlist when an error returns to
top level. This is so that lambda-binding errlist will have an effect
(assuming no one lambda-binds /). Note that / must be typed in as // since
the slash character is special tk the LISP reader.
December 6, 1977 ∪3-1,1 Page 3-3
**DRAFT** Maclisp Reference Manual **DRAFT
*
errlist VARIABLE
The value of errlist is a list of fkrms which are evaluated when control
returns to top level either because of an error or when an environment is
initially started. It doesn't apply if the environment started up was
saved using (suspend). This feature is used to provide special error
handling for subsystems written in LISP.
The symbol errlist is evaluated to get the list of forms in the binding
context in which the error occurred, but the forms themselves are evaluated
in the top-level binding context.
Example:
((lambda (errlist)
(putprop 'foo 'bar 'baz)
(hack)
(remprop 'foo 'baz))
(cons '(remprop 'foo 'baz)
errlist))
The property list of foo will be properly restored even if the computation
(hack) is aborted.
Page 3-4 ∪3-1.1 December 6, 1977
**DRAFT** The System **DRAFT**
1.2 Breakpoints
Breakpoints are a mechanism to allow the user to gain control at any point in
a program. Use of the function break causeS a read-eval-print Loop, similar to
the one at top level, to be entered. (This iq also called a break loop.) The
user may evaluate any S-expressions, inspect the bindings of variables, and exit
from the break in several ways. Normal execution then proceeds. (See , , and
page 3-31)
This mechanism can be used to permit human intervention when an unexpected
condition occurs. It is used in this way by the Maclisp error system. See the
section on Exceptional Condition Handling, page 3-15. A break loop makes the
full power of the LISP interpreter available for debugging.
break FSUBR
(break tag pred) evaluates pred, but not tag. If the value of pred is not
nil, the state of the I/O system is saved, ";bkpt tag" is typed out, and
control returns to the terminal. We say that a "break loop" has been
entered. tag may be any object. It is used only as a message typed out
(using princ) to identify the break. It is not evaluated. If pred is
omitted, t is assumed. Thus (break tag) is equivalent to (break tag t).
(break tag nil) returns nil, and produces no action whatsoever.
A break loop is a read-eval-print loop similar to top level. break does an
errset so that errors cannot cause an abnormal return from the break. A ↑x
quit, which causes an ordinary error, will thus return to the break loop if
used to interrupt a computation started in the break loop. A ↑g quit,
however, returns back to LISP top level, resetting the environment using
the errlist, as described above.
Two forms, $P and (return x), may be typed in a break loop. If $P is typed
in, break returns nil and execution continues. This "$P" is <dollar> P in
the Multics implementation, but <altmode> P in the PDP-10 implementations,
followed of course in either case by a <space> or <newline> as appropriate
(see (status linmode)). (An atom other than $P can be used to perform this
function by changing the value of $P to another (non-nil) atom. The
initial value of $P is always $P).
If (return x) is typed in, break evaluates x and returns that value. If as
December 6, 1977 ∪3-1.2 Page 3-5
**DRAFT** Maclisp Reference Manual **DRAFT
*
a result of the evaluation od a typed-in fkrm, (throw x break) is
evaluated, break returns x as its value. (Notice the distinction -
executing a form (return x) does not retqrn drom break unleqs it was typed
directly at the break loop.) See returf, .
Whenbreak returns, the state of the I/O system i@LAeKgQ←eKH8~∀
∀@@@A¬\ACaAe←qS5CiJA1∪' A⊃KMS]%iS←\↓←L@A]QChA eKCV↓I←Kf↓MWYY=of\@↓≥WiJAiQCPAiQJ4∀@@@AkgKHAae←≥eCZA
C\A[=ISMr↓iQSf↓ErAkMS]N@!ggiCQkfAEIKCWY∃mKXR8~∀
∀4∀~∀~(~∀~∀4∀~∀~(~∀
∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∃!C≥J@fZX@@@@@@@@@@@@@@@@@@@@@@@@LfZb\H@@@@@@@@@@@@@@@@A KG∃[EKdlX@bdnn~∀_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀~∀!IKMk8AEeK¬VAMKaad@Q`R~∀@@@@@PUEe∃CV@Q∃mCH@!GCId↓pRR@!GCdAβA%%↓↑s?S∃ε K∨Wn+;Qβ⊗+[↔K≤ 04!Q"F&\8 ≡Y(
∞>→8p∀Xv⊂/8H/;P"]0r47[uP∃⊂
P∩TTCE
(defun *break (breakp breAiid)
λ and breakp
(do ( @=DA]CX$@Q=n↓]SHRQKmC1Q←←V↓]SHRQ`∪↔↔βK%β I↓! αQ%↓↓X↓-%↓Bi↓5%Hh)↓↓α↓↓↓!J↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓β[ '; ∧ε@<>(∃L≡X∧pq≠2yFEλ⊂⊂∀:→y894H6yss~v2yTH⊂⊂⊂⊂λ⊂⊂≥v\pπfi@1KfACIKkKKαsSL4R↓↓↓#π∪';
α;qo ←βQβq∧¬W∞≡m_ ↑h∧P⊂λ≥P⊂*\pr⊂ &or¬
princ Breakid msgdideS) ; Newio onl`24⊂@@@!iKeAβ∪%β7≡;≠'∪-→$4$∧ααG<X
∞∀λh %∀λλλ∧∧λλλ∧∧λλλ∧π{_<nD→[p→≠P:4h→rεE⊂λ⊂∀92]8¬rn
λ (prog2 niL
c@¬iGP~(@@@@@QI↑PR@Q9SX@%α↓↓↓↓α↓↓↓↓↑#=β≠⎇∪↔[↔⊂↓#GnM⊗bπM∞&␈:⊃Q"αα∧∧ααα¬ W↔↔<X
↓QHλλ∧∧λλλ∧∧λ→≠d¬λ→3lDλ≠⊂∀\z⊂74[∀TP∀→5y6DJFA⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀74[∀BE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
1ww2λ∀∀9z_z:yP_92pu[2{2f
FE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀2{0[⊂∀9z_z:yP_92pu[2{2f
TTFEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀:⊂
9rz8H33y6H∀1ww→⊂∀92Xp⊂∀3≥w1pv≠⊂92pY⊂2wc
TFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀:⊂∀≤2pr⊂→ws∀TJTFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀_w2⊂∀≠:v6⊂≤2pr∀CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀0z≠vP3'\6TFEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
4yVpKyx0qYP∀:<Zx2ruJTFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀≥<pTTCE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀1g[2⊂∀∀→xP37\6P2gY∀P∀:→y894JTFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
∀0w2λ∩(⊂∀→xP37\6P∪R∀∀TP∀≥497{H74v⊂_92puJTFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
∀2xP
1py→5y6TH∪y2z≥y7∀FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀:~97{P
2{0vλ∀1pr≤⊂37y≠TTP1≤2puTJFE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀≥⊂∀9r]8P⊗P→7y6TCE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀894[:εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀≤rz8@
⊂∀∀6_vq20H∀∃TP
2{0vλ37y6JTFE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀8≤7sY⊂≠4v⊂∃H∀9rj≤P⊃P⊗JTTTTCE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀:2y≤94TTJTTTTJFE⊂⊂λ⊂⊂19→puTFB⊂⊂⊂⊂λ∀:2y≤94TFB⊂⊂∀TJTFEεBεE"2Xrvq2\⊂≠⊗⊂ \[[Pλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXG ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀0srP V[FEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP&pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂∃42P0\3zvr[:9P⊂≥7P19→puP⊂_y2P0H192pZx7tw≥⊂⊂4r→w:4s~qpz4[w⊂0w→⊂⊂∀7\:4ww_v6<TH0FE1≤2puPλ9{tz_t↔⊂⊂∩q⊂⊂:~2P19→puP⊂≤{tz1Z⊂2{0[:pz2\P⊂:7H74v⊗λ⊂:42[⊂74vλ⊂4yP≤2z:y≠2r↔εB'z42\;tyrK⊂⊂:4→P;0y~pq62\P⊂/8K⊂/;Vλ⊂2{0[47wuH0w2⊂λ:2y8≤4P0y→P⊂17]w2⊂:≠P⊂74[⊗⊂:4→FE;0\4pq6→yP∃⊗λ∃V⊂0[2⊂⊗P_y2P1≠zw2⊂≥7P:4→ty⊂1]y92w≥⊂;0v≥ryV⊂_w2⊂:~2P⊂6YyypsYP⊃≥q~x:εE∂192pZtr∨⊃λ4yP8≤4w:2Y↔⊂⊂ H92pr r{0v x94w≥⊂67w\⊂9tvZv0y⊂≥7P:4→P:7xλ62{2[⊂⊂67[x⊂4yCE:42[⊂2w:→y2r↔λ⊂*44\P192XuP67[x⊂4yH9zy9≠zw22Y⊂1<P_w⊂2y≤9rz↔λ⊂"y9≠y9P7\⊂⊂:<\4w3P↔<εE6Yy2v<H1pzyYP:42H192pZP67w\⊂:7P_2P92Krw:2\2r↔⊂λ*42P≥0v:rH7s⊂⊂
9z0z≥yP19→puv2]2v∀FB9ry;→yP0P→:w1z~ww⊂9Zvtv0\⊂:7P≥40z⊂≠s⊂∀9]0z:yH:7x6→{2v∀H4w⊂:~2P:7\⊂62{→v⊂67[x↔εEβE⊂⊂⊂⊂yP2pXt⊂37\6P4yH92prλ4w⊂:~2P22Y0zv:λ192pZP67w\⊗⊂:4→y2P0\2P37]y⊂1p\ry]εBεE⊂⊂λ⊂⊂_Wλ⊂"w2λ7s⊂3~v2W⊂λ#7y⊂_ww9w[2P4w≤:z⊂:~4yP6Yy2v<H4w24Xpz2yH9:q7]z⊂12↑ww2⊂≥42FEλ⊂⊂⊂⊂λ⊂⊂7:[q2y⊂≠s⊂4w≤:z⊂1Z0y0q]2y9Wλ⊂+t2]42y⊂~w8:zλ4yP3≤7vP1[w9wv→P7y⊂→v9r{Z2y2VβE⊂⊂⊂λ⊂⊂⊂⊂≥42P∀≥2y89~TP4yH27w2H0w2⊂≥42P9→pr2yλ4yP2[:2y2Y↔εEεB⊂⊂⊂⊂λ→↔⊂⊂∃42P⊂→7y6P~yP:4→P⊂0z≠vP∩(λ⊂7y⊂→xP:7H⊂:42H77w⊗[4v⊂;_v:rPλ7s⊂∩∀↔⊂⊂⊂≠4v⊂4\FE⊂⊂λ⊂⊂⊂⊂λ92z:\72r⊂→97vP≥42P1≤2puWβEεE⊂λ⊂⊂⊂→K⊂⊂*4→P37y≠P4yP
92z:\7⊂⊂;_v:rTK⊂⊂*4→P37y≠P;0v≥rP4yH2{0v≥pz2rλ⊂0w2λ92z:\72rεB⊂⊂⊂⊂λ⊂⊂⊂3≤7vP:~2P19→puWεBεE⊂⊂λ⊂⊂~↔λ⊂'z4→y;tyYP:42H37y6H4yP2]0v:p]2r⊂0[2⊂:4→P92y]v:⊂8≤4w:2Y⊂7zzλ4w⊂⊂_P6pw≠2yεEλ⊂⊂⊂⊂λ⊂⊂0w_v7sw]yP:7H:42Pλ:7x⊂≠2{2vλ92pr r{0v x94w≥⊂⊂67[x↔⊂⊂∃42P;_y4pq≠2yP⊂
V⊂⊗VβE⊂⊂⊂λ⊂⊂⊂⊂_w2⊂∃λ0y2P≥x20z→r⊂0x≤97x9~pz2v≡W⊂⊂∀∀2qpv≠⊗⊂47]r{2y ⊂:40]⊂:42↑P;ry→P17z[2εE⊂λ⊂⊂⊂⊂λ⊂7w⊂→w:9<H:7P∃_92puK⊂0w2λ9wP;Zv6⊂1→P92y]7y2rλ2{2w≥:pv6≡W∀FEβE⊂⊂⊂∃42P;X|P:7H92z:\7⊂⊂3≤7vP0H192pZP4yPλ:7P2≠P0P:~97{Pλ;tz4λ0P:0YP7s⊂λ192pZ]P:4~yFE;Zv6⊂9→z:y7λ397vH:42P_pz1tλ;t4qZ⊂9zy≤7zw2≤P:42H192pZP67w\↔⊂⊂*~4yP4\P47{H⊂1pyYyP→εB0w2⊂ P92z≥y7⊂:~2ty⊂≥0v:r\]P1p\rP~⊂≠p|P0[9wP1XzyrP_P92z≥y7⊂3≤7vP:~2P19→puWεBεEεEβEεEεBεEεEβEεEεBεEεEβEεEεB(0srH→V\⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂ YKXW→⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂⊃2qrvX2y⊂≠ ⊂_\[MFEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ
1.3 Control Characters
¬
LISP can be directed↓iVAi¬WJAGα+KCπNqβπ∂&K?;Mε∪eβ↔w#↔Kπv9↓ ∂|sSK?bβ∂#πα,⊗∨&↑.2⊂hαYTM⎇(≥~ T≥→4M]8π0v ⊂⊂*4→P⊂24Y32y2[1rP1→z;rb[⊂1w`.trol chabacters afdAUOE5CXAS9a`↔PhS'Mβ&CπQβ≤{;SK|aβ∂#∂∪π∂S-∪@~πL≥6*ε\h L\⎇λ⊂.∀≤{smd_<h∞M→>( ≡Y(⊂∩[82y2Y⊗⊂;t~v2P7≠y2pvβE0 nput o@9YrAi¬SCfA∃H ≠↔≤εBπ> Yb∧d~:αε∂=>2ε6} λ
≡ λ⊂⊃≡P:y`% kf Functions Such ApεAeK¬HX~∃=` β Jβ ↔'v9β'→∧εFF*∞MwαεLX
L]λ≤Y,≤α⊂
e@YCXKaβ∪';Q∧¬F}␈∧λ n⊂4w_P112XuP6 /op ≤~(~∀@@↓β←]iI←X@A
QCeC
iKeF↓GCL@↓EJ@AQsaKHαβ'9↓∧3@⊗@{(λ∞M→(⊂~→y0
i@9CX@A¬GG←E⊃S]N@↓iP≥β≤¬vnλβ"P_≤5qr`$ure That @⊃KaK]⊃`
β?p∧π&FT∧εNo
H -\8π:0]4swπλ⊂ P(≤5sq0[P1pwλ4pvtXP⊂:4→P2s &ectc
λkf @QQJAm¬aSOKL@AG←αsSK∨bβ∂#πα,⊗∨&↑.2ε↔∀∧ε&O,X7&Gα(⊂⊃Xv64g→P:42H⊂3:g_z4wgλ0yy`/ciated αgith the particuLar c@=]ae←αaβ/↔J↓#O↔*β ↔3⎇9%(Q!PBα∧λ⊗g&
zV =λ_smn≤[s∧ z_<L≤⎇→4NP0y2H8yzp[48 PrkceSsed aq soOn as they are typeD,
dhey may be delayed iF the@IJASfABAO¬aECO∀AG←Y1KGiS=\AS\↓ae←OIKgfA=` α2M~A↓βM→β'8hQ#+∨NsS↔K↔+CQβ'#e%βn{∪∃↓jβGπ∃¬##∃βv{';S/∪KWC"β≠W;≥#'?9αCCπ∨*↓M5EJI84(hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αα↔;S/∪';≥∧≠?;S⊗{1α∂F Kπ∂&+KMβNqα&R~α2&Nh(4)α↓α'9π##∃αM"Mβ'oβ3↔7.sSπSN{9β?2α7π∂fKOA1ε≠?;S⊗{1β∂F Kπ∂&+KMβ∂∪∃β↔w#↔K↔"β eβn+π;LhS?→β&C∃↓
≥"J1 ε[↔e↓ε{9βSF)βS↔⊗k';πbq↓α≠␈⊃↓β↔F 7C3*aα∞R∀a?
βO→β↔;&+K↔⊃αβ eβF{3∪'v84+∪␈;9↓
≥"J1 ε ;⊃↓π≠SK'↑K;≥β&C∃↓
8⊃β/↔Jq↓↓α≡{;SK}aβ∂#∂∪π∂S/∪@~εmz&n∞MO∩ε.=
rαε≡4ε∞pQ(
. <X[nt≠|H =<X⎇-\Y→>∧ [{≠
}y9 /(≥~ T_z_.,8⎇→.%C"C!$λλ∩-dλ∪Y.⎇;kλ ≥↑(λ =_8X,>→<H ≡λλ_-Mλ≠8/∀λ_Y$
89→$∧_;H
≥]→<N.<≥λ∧ z_<L≤⎇→<EDλ∀y,Q"J≤n>_=≥.4≥≥≡%∀_;Y∧¬≤|⎇ ≡≥<h∞N≡:;NE+C"AQHλλ ≥]→<N.<≥λ =_<X,>→<\d∧_<Y$ ;≤{d∧≤Y8,D_<h∧∞_<]∧
yHλ∞M→(≥ ↑[:;L≥λλ~-n≥=λ∞>≤Y8-UA"SM}[8;
O(≥~ ←(_<LT≠8<M<9λ~-d≥~→$∞Y89∞L8[→$ <hλN⎇|]~
L<|hD z_<L≤⎇→<N5C"C!$λλλ∧∧λλλ∧∧λλλ∧∧λλ⊃-n→<Z-lh⊂{mn≤[{∧λz_<L≤⎇→<N∀~;H
It∀k&⊗λ∪∩*:β"C!$λλ∪-}⎇λ_m⎇]≤[mD_z_.,8⎇→..h≠8/∀_Y( ]]→<L\λ~;D∞~→(∞<;9(∞|>(_.4~;H ~∀h∪ ~tλ~,d∪∩4j↓ Z<d ⎇<\L]]≠≡$∞Y89∧⎇;Yh n[{(∞M→(≥ ↑[:;L≥ Hλ ≤H_( I4tλ∞∞[y|L≥(~<d 8⎇~.l;≡(∞.;[Z-lkβ"M≡λ~<d
Y8y.>x<↑$∞≠h→M≡\⎇λ |:;H∧
=≤h ≡≥→;NM;{H /(≥≡.
;Yh∞M→(⊂jJS xd∧_z_.,8⎇→.$≠{Y!Q[|H∞N{h≥
≥9<k∧∞~→<L\↑(≤L↑≥<[M≥Yh≥
t≥~→$
;{Z.M|KH∧
~→(
]{Z=
}H_{m]8;Y∧
Q13JH4H≠,∨#"]
;H_LT≥<y,D≥≠h∞,+9;NL<H≥
(λ∪ ~t H∧ ∩4t∧∞z;≠∧∞≤Z;NDλOwD$_;Y∧∞Y89∧∧_(_m <X8nL<Kβ!.z~8m∧≠8>$ Y(_$ {{]∞-{λ_m <X8nL<H≠n$_(_m <X8nL<H≥m
|y(∧,{{]∞-{λH
\8;Z-lh~<d∞≠h_LQ"]<l\ Hλ
M≥<h∞O<~;Lt→:=
<Hλ lh≠|D∧QhH∞⎇;≠λ <=<y$∧≥~→$ Yh~-n→<\N↑≥λ≥
tλ≠xl><KH∧ 9C"II4tλ
≡h≠[nD≤Y8,O(≥≠d∞_:y$ ;H~-n→<\N↑≥ λ∞M→<Y$
8>( ,(_( L;_>$ Y9[n,(≥~ TλλOkdH~<aQ\≤Z-n→9 AQC"JE%JJTh→3⊂JE%JJC!!"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧λ;]→.-;Yhλ={]≤M⎇λ⊂z ≡X8⎇ ↑\h~-d∀p2)D∪∩4j↓"C"D∧λ⊂{mn≤[{∧ z_<L≤⎇→<N4_<Y$ ;]→.,9λ_O∀→Z<N>λ→y.N~;Yd∞~→( ≡≥→;NM;{H I4tλ /(λ≥∂≡~;YaQHO⊂h→∪∂HD ;Yλ∞M→;H∧*Q13JH4HKDλ=λ≥
<hλ∞
z;]∧ {{]∞-{λ_m <X8nL<\h∞⎇;≠λ ,(λ_,<|→= \β"X.4~;H∞M→(λ∞>_;Y ≡Yλ∃ z∀k,&∧λ~;.
→;9-n_=~-⎇KH⊂-N→<[L≡~=Y-O+λ≠ml(λ_l≥H→;L≤[→(∧∞~→#!'→8z'i(~;NL<\].∞λλ_-lλ~_.l(λ_-dλ~;NL<\].∞λ≤[n↑~;Y$∧≤z;.]_=→$∞~→(∧π⊂p3 GHλ∀HX3U⊃*!"\y.≡9;XlUC"C!%JJJE*p23λUJJJE!"Q→,<;8Y.$
Kλε↔-mh∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλα6k,+F4λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ
9y(ε5.#"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~<n∧∀Y9L↑Y;XlT∪8;N\;λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1U
E!"C"AQHλλ∧∧λλλ∧∧λλλ∧∧λλλλ]]→<M≥Yh⊂m⎇]≤[mD⊂z_.,8⎇→..h~;D =;≥
≤|h∪ ~tβ"AQHλλ ≥H≥~ T∪=;∞M8|h
≥<≠→-\;]_.M;{H
|H∪8,=~<|¬D≠{Y$∞z9{L≥≤h≠ml)|h L<z<LT≥≠h ]]→<D #"HL={]≤M⎇λH_m <X8nL<H_O∀λ~~.N~;Yd∞~→(∧,=≥→-n~;{D$~y>$∧≠{H∞M→(≥ ↑[:;L≥ Hλ∧¬∃~~.4~<c!,x;≠ \λλXN,8:k∧$λλZ-n→<\N↑≥ λD∧X=≥
eλHλN≡:= ∧$λ→= 5H≠{D ~9YL↑Y;]∧∧≥→<M];X;∞5Hλ∩,a"S=-N~8|d
<h_L];Yh ≤xy<n<9λ≥
∞[⎇9m∧≥~→$λ4T⊂$
Y=≥m}Zkλ ≥HλZ-n→<\N↑≥λ≤∞-xy<n4H
⊂
4∀c"M}H⊂∀d (∀λ n[{( ∀∃∩4¬∀≤z9ml;λ≤m
⎇;→∧ Y(≥∞,;\{-≡≥→9¬e(∪∩*:λ≤Y.>≠{Y∞4_↑(∞O<~;Lt≠⎇=↓QHPu
) hKD∧∪[⎇d∂;⎇(
\>(≥∂≡→(≠ml(≠→.N→<H n[{(∞M→(≠
≡⎇λ≠ ≡→<H
≥H≥~
≡h≤y,>~;{ED≥z~,=β"]m≥≠λ_LT~;] ↑\≤Y.L9λ≥
t~_=LT~=≤d∧X{{NN[{λD
98;M≥YkH∧
~~<d {{]∞-{λλ =_<X,>→<H
↑<⎇β!,Y(→M⎇≠≠⎇l\λ_↑$ (≠Y.⎇~;Y%a"C"D∧λ∩=∧
<hλ ≥≤{h∞
||z,-→(≥
tλ→;NL<HλL={]≤M⎇λH_m <X8nL<\h∧ \[{$ ;Hλ
≥\≥=∧ z_<L≤⎇→<AQ\⎇≤L\;+λ∞⎇~8z∧
8>(
=Y(
≡≤h≤m}<Xy$ =λ≥
(≥→.-:;X-D≠|H
≥H_;D >→8k|{{+∧∞z=~
}=λ≥
#"].<(≠yD∞~→(∧,=≥→-n~;{D$~y>%dλ∃~ T→→<m≡Y9λ ={]≤M⎇λ_z ≡X8⎇ ↑H~<d∞≤Y9M∨→9 /(_( F iC!,z_<L≤⎇→<E@⊂⊂$sλ:;wP≠s⊂:4→yrP8≤2s4|λ1t0y_qz2y≤β occur togather, one \036 character
is read and no "control action is perforied∞ Otherwise, the character
fkllOwing the \036 iq processed as a coNtrol character, then reading continues.
Contrkl characters will be accepted in uppep or lower case. All characters
other than those with defined maanings are rejected with an error message. Only
gne control character may be entered at a time.
Example for MulTics LISP:
(lines containing user input are preceded by ">>>")
>>> (defun loop (x) (loop (add1 x)))
lkop
>>> (hoop 0)
function runs for a long time,
>>> <ATTN> then user hits attention button.
>>> CTRL/B LISP types "CTRL/", usep types "B"
>>> ;bkpt ↑b system enterq break loop
>>> x useR looks atvalee of x
4067
>≡> <ATTN: user @!SifA¬iaK]QS←\A kii←8ACOC%\~∀@@@@@x||@@@Aπ)I_←∞@↓C]HAIKike9fAi↑↓iP∨Aεc↔[↔`h)↓↓α↓↓↓↓α↓↓↓↓ααGW' h!↓↓α↓↓↓↓α↓↓↓↓α↓(4
>C↔9↓ε ↓ W≤+A↓βLsS↔K↔+CQ ∧¬↔4λ_x.↑y9⊗λ4s⊂⊂≥42P4[:2y9≥x:⊂⊂~yP77]⊂⊂2w_q62rλ73p∀hing
happ@∃]fL@↓∪@→β&C∃β'w#↔KK,επ"ε≡4ε.v≤-F."βλ⊂~~2s⊂0H8yr`2-spe@
SMCK⊂AMk]
iSO\↓SfAG¬YP∪↔ ¬`hUM RεNnLWπ↔↑
BεN∨∀ε⊗* X L≤[→1∧∧_↑( -9Y~-lh≥~ T_8λ(≤5x94Xz2P9↑vq7fλ:7P⊂≥42P#≥w1z4[wεE 4o handhe It, oR by Uqi`≥NαβS#∃αCGOS∂#WMβ'#g'≠ Iβ≠Wv≠S'∨p↓#Cπ>)↓M∃C↓%8Q!PP@"T_,|(λk&⊗λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλα⊗k(#F4λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧⊃→0⊃Yvq2iλ≠⊗⊂_NXπ7
**DRAFT** The System ∀U⊃%β
λαQ( (!Q hR∧∧∧Nr∞Mε*εmx
Mβ{tg→β deScr`∪@¬#'?;~↓β >dλλm⎇]_[mD_z_.0qz2\αs _Aβ## ?<Tπ>F≤9ααε<≥bε∞β_ p↑yFE "e proc` ggα+⊃β'nk↔β'∂#↔3@∃Dαε/lX D ≥<Z-lh_ ⊂λ3pq1_pπe @
←YYKα≠S'⎇`λ
}Hλ⊂∀[⊂⊂λnointe@I` @/∞AP@$βz2<JP6w`$e(λAo%YP⊃β⊗)β'lM⊗≡∂LX ∧ ↑(⊂⊂[⊂⊃⊂@" f`∨dαβS#∃∧JRMβ∞s⊃αR⎇αM +⊗∧εNo
H -\αp∞tati`∨]LX⊂∀,≥f"ε≥`λ∧∃⊃⊂ &or the @≠k1iSGf↓∪[aYα+7.β]~-⎇KHλ
@t2w appropr`∪CQJP⊃β,ε↔.Ol≥F.wD DM≥∧λλm|α2FE~yP3t]2s⊂ &or p@I←@∪W≤¬⊗v:∞Mε*π<≥V*π,Z7.gDλ N4πm @∧A`↔O,ε"ππ-x n0p
.
λ∧⊂∀(8 mnα97`, Characte@I`
βSF Qβ#∂3∃β'vKS'πd¬GJεLX M≥Y9⊂≠p¬anings @%\ACYαaβ'↑ F.n]nF∂&≥x N]
↑b).
C !* sets the value of the atom ↑d to nil, turning off garbage collector
messages. Because ↑c is trapped by DEC-10 monitors, this control
character can only be typed using the REENTER mechanism and typing
"C". (setq ↑d nil).
D !* sets the value of the atom ↑d to t, turning on garbage collector
massages. (setq ↑d t)
G quits back to the top level of LISP, rebinding all variables to their
global values, resetting various system variables, and evaluating the
errlist forms. This is used to stop a running program when there is
no intention of restarting it again. (Prints out a *; see the "top
level" function and the ↑g function.) H is used instead of ↑b in some
implementations (see above).
Q ! sets the value of the atom ↑q to t, enabling input from the source
selected by the value of infile, or selected by use of the function
uread. In the PDP-10 Newio implementation, this is not an interrupt
character; instead it is a macro character, and takes effect only if
processed by read. (setq ↑q t).
R ! sets the value of the atom ↑r to t, enabling output to the
destinations selected by the value of outfiles, or selected by use of
the uwrite function. (setq ↑r t).
S ! turns off typeout until input is read. This is used to suppress the
rest of the typeout from the current request, without affecting
typeout from the next request that is typed in. It is implemented by
setting ↑w to t, then putting a macro character in the input stream
which sets ↑w to nil and does a (terpri) when it is read.
December 6, 1977 ∪3-1.3 Page 3-11
**DRAFT** Maclisp Reference Manual **DRAFT**
T ! sets the value of the atom ↑r to nil, disabling output to the
destinations that CTRL/r enables. (setq ↑r nil).
U causes the current call to read to be restarted from the beginning.
(Not available in PDP-10 implementations).
V ! sets the value of the atom ↑w to nil, enabling output to the terminal.
(setq ↑w nil).
W ! sets the value of the atom ↑w to t, disabling output to the terminal.
(setq ↑w t) (and possible also (clear-output tyo)).
X causes an error which can be caught by errset. This is a less drastic
"quit" than CTRL/g. If it is typed within a break loop, it will
return no further than the break loop, since break uses errset.
(error 'quit).
Z !* On ITS returns to IPS command level, i,e. DDT. On Multics returns to
Multicq coMmand level. (start Re-enters LISP.) On TOPS-10 goeq to DDT
if a DDT has been loaded with LISP.
The follkwing control characters only exist in the Multicq implementation.
. !* does nothing, and iq used meRely @Q↑Aga∃KHAk@ABAg1←nAaI←GKgLAErA
CkgS9N~∀@@@@@@@AC8AS]i∃aCGi%←\\~(~∀@@|@BT@@ACgα[EβSF)α2&≥↓βOW↔≠gOS.iβ←#∂!β'Q∧K@~εMy⊗v;$∞'.vm_ LUλ≥x-≡~;Yd∧→[p→λ4s8:]⊗εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂![v62a]4s3@ earbaee, @=` βK.s;'≠8∧π>OMπ'πα+:-n→<\N↑≥≤h
\<zy,D≠yQE@∧AεEλ⊂⊂*4→P37f≠4πwine cOnproL characteRpεA←]1r@AKβC'OQ∧¬⊗r¬λJαk ∧∧εNo
H -\αp∞tatigns with
the "eo@ rA%|y↓β∂∂βπ πd¬↔'Jd∧αDXπp∩↓]WnX↓iQSF↓[@↔πw→β >mH∞$ =λ⊂~~2P&dU⊂ dP∪0q7`2atory,)~∀!`∂.T¬π>⎇_=∞↑h≥≥∂≡xx;E∃α⊂8 Yp¬ &4pdR\4⊂⊂∀$∧∧2α∧∧αααλ8λ.↑y(⊃n0x44XyP24\βplay slave to pπ@↔≥( $ (→~.x60|Kα ∀~(@A @@@@@↓)`↔Kp∧ε}r M↔>≠_>$ Xπy cha`%¬GiKdαβ?WS∧εW"pβ"C!∧λ∪h∧∧λλλ∧
≥<[D
βs3⊂→4yx ,ay f@=` β∂F @⊗∞>LWαε|X
∞∞αz↔εBαλ
)ααe↓↓α↓↓↓α≤∧↔/≡Tλ
≡|≠⊂⊂↑P9v !ve to rel@∃CgJAα#'OCd∧↔J@@εEεBα The @→←YY←β;';≥∧∧6}wL∧[mDλ_p∀_y0q`4ers @=]Q`%αβ←?KX∧εNr∧λ
(λ∀λJλεP⊃⊂ iepLementatio@8Xλ$!Q hU ≤v*β5P &$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f5αXW3 @ KGα+7 ↔⊂∧β %λλ ≤Mβ3
**DRAFT** The System **DRAFT(T~∀~(~∃)Q∃rACe∀A]←hAeKC1YrAS9iKeeUaifX↓EkhA=GGkdA←]YdAoQK8Aae←
KggK⊂AEr@↓iQJAQKe[S9CX~∃%]akh↓aeKg
C]]KH@QgK∀@QggQCikf↓iisg
C\RX↓aCOJfZpd$\~∀~(@A⊗@@@@@↓eKISMaYCr↓iQJA
keeK9hAS]Akh\@↓)QSfACYY=ofAs=jAi↑↓OKhA∧AGYK¬\@AG=arA←_~∀@@@@@@@As←UdAS]AkhAC→iKdAIkE←kQfAQCYJAEK∃\Akg∃H\@@!∨\AB↓ISga1Cr@A
←]g←1JXA→%' ~∀@@@@@@@A]SYXA¬iiK[AhAi↑↓[CWJ↓ecEE∃H[←kPAGQCICGiKIfACGQkCYYdAISg¬aaKCHAMe←4AiQJ4∀@@@@@@@AgGe∃K\\@↓=VASLAgiS1XAkg∃MkXA%LABAQS[S]≤AKee=dAISMekaiLAiQSLAae←
Kgf\$~∀~∀A_@@@@@A∃eCgKLAiQJ↓gGeK∃\ASL↓iQJAQKe[S9CXASLABAI%gaYCdXAiQ∃\AI←∃fABA
)%_←,\~∀~(~∀@@@@@@@@@@@@@@@@@@@@Aπ=]ie←0[πQCICGiKHA
k]
iS←]L~∀~∀4∃=N@@@@@@@@@@@@@A'+¬H@`ACIOf~∀4∀@@@A!e←⊃kGKf↓BAck%hAi↑↓i←`A1KmKX↓Ukgh↓CfAS_ABAπQ%_←N↓QCHA KK\AQsaKH8~∀~∀4∀@@AQQKgJ@AMk9GiS←9f@AKaSgh@A←]Yd@AS\@AiQ∀@A! @Zb`@A∨YI%↑@AC9H@@AQQJ@A5kYiS
f~∃S5aYK[∃]iCi%←]f\A)QKdACeJAEKS9NAaQ¬gKHA=khXAM↑@AkMS]NAQQKZA%\A]K\@Aae=OeC[LASf~)]←hAIKG←[5K]IK⊂\~∀~(~∃S← @@@@@@@@@@@@@A
'U¬$~∀4∀@@@A)QJ↓CeOk5K]hAQ↑AS← ASfAAe←GKMgKH@↓CfAS_AShA]KeJA∧@EG←9ie←XAGQCICGiKHDAiQ¬h~∀@@@AQ¬HAEK∃\AisAKH@A%\\@A9k[EKIfACe∀AiCW∃\@ACLABAo!←YJX↓Ci←[%F@Age[E←YLNAa]¬[Kf~(@@@@↓CeJ@↓ae←G∃ggKHAGQCICGiKH@AErAGQCICGiKHX@AKaGKahAiQCP@A]S0@@ASL@ASOc vt) switches output to the terminal.
(ioc q) switches input to a file.
(ioc g) quits back to the top level of LISP.
If ioc returns, its value is t.
December 6, 1977 ∪3-1.3 Page 3-13
**DRAFT** Maclisp Reference Eanual "*DRAFT
*
aog FSUBR¬
iog d¬SegPAgCmα+E↓β&C∃β[∞cW/4
v $λ≥~ T∩+sd∞⎇z= =→<h n+λλ nKλ⊂-lλ↔]eDλλ∃
;H~.A Hλ∧∧λ≤∀M|y<|l↑h~=∞∀→Z4N>λ_<L↑;93ND≥~→$∞x;9$ <h~-|kHλ l>≥λ∞M→(≤L]8:;M≥Yh_.,⎇;9-n≤c"D∧λλλ∞MβP4wYP0y2H2{0v≥pz2r ⊂397[P62s≥⊂:7P≤4st: ⊂⊂*4→P;0v≥pyP7Y⊂:42H⊂;0y~pq62\P/8VβE⊂⊂⊂λ⊂/9⊗λ0w2⊂↔;P0y→P⊂92\z7y2Y⊗⊂0w→⊂:42H;0v:YP⊂7sλ:42P≠0yz⊂_y3zvYw:⊂⊂~yP92]:y72Y↔εE⊂λ⊂⊂⊂"↑0vx6→]εEεBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀4[sP;:λ∀894[1P⊃ H&ryyXsrW⊃
TFEεB⊂⊂⊂⊂λ3rz9H0P6r\ypsrH:7P:~2P1g[9wv2H⊂77P≠pz:2\⊂;t0]⊂:42H$WgP≤|yz2[P4yPλ27tw→W⊂⊂$]εA⊂⊂λ⊂⊂2{_v:pz→yP:7H⊃ P&YyypsYW⊃εEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀4wYP0P< P<→⊂ ↔↔⊂<≠∀FEεB⊂⊂⊂⊂λ1pw⊂_v9wP_2P;y~z:2wβEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀
60vq→0P∀/≤P/9⊂↔;TFEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀~wqP0JFE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂<_FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂≡→εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂↔↔ εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂<7∀CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂74[⊂74vλ74v∀CEεEεBεEεEβEεEεBεEεEβEεEεBεEεEβEεEεBεEεE∀0srP VXZ⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂ YVLW→P⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂"→qrvq→y⊂≠⊗λ_\[[CEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊃∃"∀ c***
1.P@A q
KaiS=]CHA
←]ISβ#'?9∧Cπ;∪d¬⊗v8Q!P@hαC"F∃β~↔1 The LISP Ar`%=`A'sMiKJ~(~∀
∀@A)Q∀@AKeI←ef@↓IKiK
iKH@↓Er@AQQJ@A1∪' @↓`∂gO&+5↓β∂∪∃↓β&K['∪,!↓β'w#=↓β';=↓β'KC↔Mβ!P@,{x\L\⎇_8ML(_;LD≥;Xm}\Y0⊃]0q6 %,∧@A !JAk]
←eeKα≠Sπ d∧Rε/,∧[n9P;t[4∧ be expLai`≥Kα!β≠≤.7 Hα\p∀[1rP 4hey Ape s@%[aYKβ⊃0⊂@ ¬εEλ⊂⊂ wλ8¬fc@=` K↔≤εF∞⊗β→(∧ <X 7\α ic an @∃` K| λ∞M_9⊂_pzy`%pε@Ai!JAKmα 3@.≤M⊗}r
_ D∧≥z~,=λ~0~βE0∂c@
kefAβ#=β *βπ |.F.λπ⊂⊂∃βhen↓C\Ak9G←ee∃GiCE1JAKeI←dA←α≠∂WK~aβC#*β⊂⊗O,∧p~λ⊂:44[3P:4_zεE (appe@9`
β'~βS#∃∧επεNnM⊗v:
x D 8π⊂⊂→y97`2 h KgMC@∨∃p∧α∧NβH∪mL~;k∧∞~→( ↑\[p→λ⊂6ri\βage eoes
λ¬`∪=∧εFF*∞LW-αp nal and h
O@>C↔K∃∧∧Vg≡T¬π.vLX nP9z`0pres@MK@⊃Dλ l\αP2`2p¬gKhαaβCπ>)↓↓Mhε#
JDλ Mq [8.Nα2y ho`.↓iQJ@↓∩P≡tλ n⎇=_p∀→yP⊂ !nd v@¬` 'π⊗c↔M↓∧ @⊗*∞8 .EHλλ ≥H∪Y.⎇8πV⊂λ8∧he vari@¬EQJ~)[gOMαK3↔M∧¬↔4_(⊂⊗~yz⊂ /d∧AiQ∀@AMSαc↔Mβ&yβO#L∧6Bε↑.&␈∩
\W>x9y.P9t7]v2⊂ "e routedlAaQSβ_4+≥m↔&N≥H ∂∀~8 P~αp ghαβS#∃∧εF/⊗β:0↔_v⊂∞ The @∃` K∨α λ
\αyy`Yp¬ c@=]gS@≥#@~ε|dαπ≡⎇\Rε/∞λ ≥X8
7\αy~∃β#↔cQ∧∧⊗v"¬∞W∂.≥H ∂∃(≥~ T≠xZL\⎇λ⊂↔\α fo@IZAiQ¬hAGCUcCHAβ##∃β,ε'-βy↔εB∧¬∀@AβMi∃`AiQ∀@AKeI←dA[∃`∂Oπ>)β#π~↓β ↔,¬bππ-→g&.EDε≡}nN&}b∧ ↔4≤Y5∞↑Xπ2`$ to the most
receNt eRpor-catcher. There is an ep¬e←dαk∂πS≡C↔Iβ∂!↓βS␈↓↓β3-3↔1⊃αβπ;⊃∧+CK∨⊂h4+∂∂#∂#↔↔→βπK*βOπQ¬+Aβ JβS#∃ε3W;∂&K?9β-∪@↔≡↑DαF∞l@ε↔⊗\≥2bπ⎇
⊗≡B∞↑6/~∧ W.\y0~
Tε All
var`∪C YJ@A S]IS9Of@A KioK∃\AiQ∀@AKeI←d[G¬iGQKH@AC]⊂AiQJAa←S9h@Ao!KeJ@↓iQJA∃` K?⊂h+?∂≥+KK↔"βπK∃π∪↔OS␈∪↔⊃9ααS#W~βπ31αβ[πKN 3↔~βπK∃π∪↔OS␈∪↔⊃β&yβS#*β[π3.+E↓β&C↔eβF ⊂4+∂!βS?αβ3↔[,aβ?Iε QβSF)βS'n)↓βSF)β↔K↔≠↔Qβ> Mβ∪}s∃1β.s3↔O~βS#↔Jβ←↔K*↓βO↔' ∨↔⊃ε3K↔∀hQ#←'&C?WQ∧∪↔';:β ?Wv!%8∀Ph)↓↓¬;#πQεCπCC.sMβ;/CQβ∪/β↔;∪~β?9βF{]βSF)β↔K⊗{I7∂∂#∂#↔∩β←πMπ≠↔Qβ/↓9↓α∂!βS?αβ3↔[.a04+&C∃↓β6{K7Mε{9↓β&C∃β↔↔∪3'O"↓βπK*↓β↔[∞cWπS.!βπ;"↓βS#*βS/Aαβ3↔[,aβ3?␈↓↓↓#⎇⊃↓⬬+O↔HhSOC↔≡K≠'↔"βS?Aεc↔[↔bβ≠?KjIβ'Mπ∪∃7↔w#↔K↔"q↓↓"&C∃βONk ?1ε+KK3O≠Qβ'~β↔[πg+πS↔"βCK'␈⊂4+SzβS#∃ε ?[*βK↔O&{KπSN{9β?2β ';&K;∨Mbβπ;⊃π≠π[↔"β'9β&C∃β[∂∪'π f)↓=9αα'9↓π##'Mπ;πd4W##∃↓ε+KK3O≠QβW≡+⊃↓βO→βS#*↓β?;*β∂WK⊗+;Q↓ε QβSF)↓βSNk∃β?2↓βS#*β↔KK␈⊃1↓β&+OC'&)βS#(h+K↔∨#?Kπ&K?9β}1β 'v#';∨~q%α'2βπ9β/∪K?Iπ∪↔SW⊗sMβSzβ K↔∞Y1β'"βO'7εce↓β⊗)7↔;&+KMβO#L4+⊗+π⊃7/3π17π∪';Qεc??Ar↓↓α'rβS#∃αα7W3&K∂MβNkC3↔n+;Sπ&K?9β&C∃↓β6 ∂Qβ&CπQ↓ε∪K↔πZβ#πLhS∂πW>CQβπrβ↔KK␈⊃β'Mπ≠'∨;∞c3↔⊃ε∪e↓β⊗K;∨'v9βS#*β ↔3bβ?9β&C∃βS/∪7';∞a9↓αN1↓βπrβ↔KK␈⊂4+K/#WK;~βS=↓ε+KKO/!1β↔↔∪O↔QαβK↔S/∪;MβvK1↓β∞s⊃β↔6 3Wπ&K?9↓πβK?∂.+∪M9αα'→↓ε 9β↔↔∪?H4W∪↔SW⊗sMβSzβS?Aεc↔[↔baβS#*βOSπ&)β?→π##∃β>{K3⊃εKMβK/≠↔Qβ∞s⊃↓)εKMβSOβ↔⊃8hP4)↓ααS#∃αβπ ?6)↓β∪/≠∂K'π#'?9εKM↓β≡c'∨#&ce↓β≡K7C3N3'↔⊃r↓αS#*↓βWO/⊃↓β∂∞q↓βK/ W↔O"βπ84VK;S↔↔∪WCQαβS=β}≠∂WIαβ ↔S>+↔9β&C∃↓β'KC';:β?→↓π##∃βn+OOπ>)1↓β∞s⊃βSF)↓βWw;';∪Ns≥β?0h+ 'v#';∨~βπ;⊃π∪↔SW⊗qβ?→αβ∂?;'∪?1β&yβπ9ε+KK?∩k∂πS≡C↔I9α↓α'→π##∃β/∪K?IεKM↓β>{';≥π#<4(hP4*∪.≠↔7 /⊃↓Y1β e]]α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓↓→M5Es!↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓αε ∨∃↓~iET4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK.3↔K↔v≠∃α7∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4+K/#WK9π#=↓β&{Aβ3/3↔11αβS#∃αSKO↔"kSKπα↓βWO/⊃β';&+KKWπ!↓β'~βO'∨v 33↔"q↓↓α&C'Mβ/≠↔H4VK;S↔↔∪WCQεKM↓βNs'S'∞c3eβ
βOgO&+57O/βC3'.!↓β ⊗+π-βf{?Aβ>C'∂!αβπ33␈;MβSF)↓βW≡+IβSxh+↔c∞k';∃π##∃↓π3π3W/→β?→π3πK'∞∪3↔Mαβ ↔≠␈∪∃βSF)β 'v#';∨~↓βπK*βK↔O&{K↔⊃bβ'9↓εC?C∃ε{_4+6K;∪'v9βS#*β∂πW≡)β?→π##∃β/∪K?Ir↓α'9αA+KO/!βQ%εk?∪∃ε β K. -β3}{Aβ'~↓β↔;&+K↔⊃bβ WPhS'9↓BSKO↔"β;'1J↓β7?&)βS#*βWO↔∩↓β';&+KKWπ!β'MεK∨;?⊗+⊃9↓∧K→↓β&C∃β↔↔∪?IβO→↓β∨}K;≥β&x4+K/#WK9π#=β¬ε∪K↔πZβ?Iβ∞qβ↔K↔≠↔Q1ε ;⊃↓W∪O↔QεKMβ;}q7;'baβS#*β↔KK≡+Q↓β/≠↔IβNsS↔K↔+CP4VKM↓β≡K∨;πfc↔⊃9α↓αS#*↓β';O#'π1αβ↔;[O∪?;7.sQ↓β≡{;SπNsM↓β
↓β;Wfa↓β#∞s∪3↔∩↓β≠?∩βS#'_h+';&+KKWπ!1β /!βS#*βWO↔∩β7πeπ≠WCCgIβ¬β↔∪↔π-εc??Aε{Iβ?&C↔IβF ;∪3/⊃84(hQ↓↓α≡{KK↔∨#π 3*β↔KK␈∪Mβπ⊗)↓β↔↔∪?KMπ;#'∂Bβ7πeαβ ∃β≡{KK↔∨#↔⊃β↔I↓βW≡+Aβ'w#↔K[.sS'?rp4*'2βOW∂Bβπ9β/∪K?IεKMβC⊗{C↔KgI↓β∂␈∪K↔∂&+⊃1β/3π3W∂#'?9π;'31πβK?∂.+⊃βπ~β'→↓εs=β↔↔∪?H4VCπ⊃β}≠∂WK⊗+⊃9↓∧K→βSF)β?C&K?9β&yβ∂?↔∪↔∂Qπ##∃β/∪K?IεKMβ;␈!β↔c/∪∂'O.!1βSFKMβSOβ∃β?0h+↔K⊗{Iβ←Nc1β *β#π;&c↔⊃β∂→β'→εKQβ←/∪∃βπrβW;∂␈∪K↔∂& 3∃ε+CK?∩p4(4R↓↓α←F+9β¬ε≠?KK.≠Sπ f)β↔K⊗{Iβ?≡≠WKMbβ¬βW≡+Aβ'w#↔KK/βQβ'~βO'∨v 33↔ q↓αO,)↓βC∞;∃↓Mhh)EEαβ≠?IαβWO↔∩↓β';&+KKWπ!↓β∂F ;;↔bβπOON;;7↔w#M↓β6{A↓β&C↔O∃αβ↔KK␈∪M9↓e error and then enter a break
doop.
The argument passed to the user interruPt handler is an S-expression
describing the epror. SeE sec@QS←\@bTh\HAM←d↓IKiC%Yf\@A∪LAQQJ@AUgKdA%]iKeIkah~)QC]I1Kd@A%bA]S0X@A←H@ASL↓Sh@AIKike9f@AB↓]←\[1SghXAiQJAKee=dASfAieK¬iKH@↓CfAC8~∃k]
←eeK
iCEY∀AKee=d\@A kh@A%H βSF)β#πv#3↔I¬∪↔SW⊗sM↓β
β3'O"aβS#*β∪'K≥!↓β↔d+7↔;"β?_4W##πQ∧c'OQεKEβW≡+⊃βSzβ∂?K⊗+∂Qβ&C∃β↔↔∪?IβLqβ¬β> eβ←FK∂!β&+C↔;'→β?9αβS#∃πβπKSN≠W3π⊂h+↔K⊗{Iβ←FK∂!β}≠∂WK⊗+⊃84Ph)↓↓∧K→βSF)β7∨≥!βK↔≡+;Qβ/∪K/In≠πS∂F+Iβ'~β;?Qπ#?A↔d+[↔1bβ∂?K⊗+∂Sπ⊗c∃β↔↔∪?KMπ;'31ε∪∀4+'∪↔πS.!↓βπ~βW;∂␈∪K↔∂& #∃αβ↔KK␈∪EβWvc↔OMαβS#↔⊗)β'Mαβ¬β;}q7;Wda↓β#∞s∪3↔∩↓β≠?∩βS#∀hS↔KK≤+Qβ'w#↔KK-βQ9↓¬##'MεKE↓β&yβCK/3↔;Q∧∧6}vn↑6Nvt∧&o.NM↔εg∀ f/∨L\B∩α ↑'ε←$ '⊗.≥>0hW]mF/∨4∞FF*∞↑6/∩
→f&N<≡F/~∞Mε∂"
Rαε≡4π≡␈
↔∂&≤<↔&.Dλ'Jπ<ZG&Nlpλ∞↑λ_ ∧
_;Y
L<H⊃M}A"U
(→0→≤αsetinterpqpt. (The e@I` O↔"β#π;&c↔IβM#@≡.LdαεO4
vvg∀ ⊗w6⎇<V"ε≤dααW,8W"ε≤1PVV⎇eVvNEDεF␈|↑f/∩e⊃PPH$∧α¬≡\Tπ&FTλg.v>M⊗}w4λW.[xC∧ <\@⊗λ0s2 errc@∃h\
∀4∀∩∀b8h\d@↓+gKd↓∪]iKI` GC'_4(Q!PRα∧ DM≥∧∞πε␈m_F/~ ⊂εw.\,Wαε|dα↔<y4D
;]→.∞]<≥∞∃α⊃⊂;Z4qt⊂_y2P0H6rq`(anisM by Which a
u@MKd@AAeWGKα#WK∃αβ7πeαβS↔7ε{@⊗∂-→GJε|≥⊗rα 9vw'-yBαπ⎇ Vrα ≥bαε← 6/πM≥vv∞Dλλm⎇Y~5
≥{C"AQ@εE(_qrP→KX[⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXG
↔_P⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂"2Xrrq2\⊂≠⊗⊂ \[[FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE40x≤2w9Wλ⊂*42H2|1r\:4ww_v⊂1w[24z4[w9P:~0z⊂:\rP:4→P:yr\⊂4w:→y9:x≥⊂⊂9|\z2vP~w1v:Y2FE1Yy:0t[⊂1ww≥97v⊂_t0y0Xz2y9K⊂:42H0v0y≠qv7qZP:4vYy9V⊂_y|w1Z97w7]yP⊂$KgP1w[24z4[w9VεB:42Pλ3py1_srP⊂_wv62Xz7y⊗λ⊂0w2λ⊂6pw≡P⊂7sλ:42Pλ2y97\9P⊂:~0z⊂⊂_y2P⊂→2z2q]2r⊂⊂_<P:4→FE4w≥2y89→z2y⊂≠y⊂1<H:42P≤|yz2[P⊂3:[1z4w[9W⊂⊂⊃y97y≤P22z→qz2rλ1<P:\ry⊂⊂→:w1z~ww9P_pwεE≥yrP:~4yP6Yqt0w~yvP0[9wWεBεE⊂⊂λ*42P≥yry⊂~w:2y≤:x:9H0y2P→4{4b→r⊂⊂:\⊂4w:≠P9r{→y0v⊂_t0w7→v9W⊂λ"pqtλ⊂1t0[72v⊂~0yFE_yywqZpz2rλ⊂;tz~⊂⊂4zλ⊂0P⊂≤ry;4XrP3:[1z4w[↔⊂⊂⊂∩q⊂⊂:~2P⊂9Yy;4qYP⊂3:[1z4w[⊂⊂4yH74v⊗βE4w:→y9:x≥9P7wλ:40zλ1t0w≠2v⊂+Zv6⊂1→P4sw≠y2rπλ⊂$s⊂≥42P9Yy;4aYP3:w_z4wwλ4yP7≠z⊂74[⊗εE4]⊂⊂4yH0P⊂3≥w1z4[w⊂;t~qt⊂⊂~yP1p[62rλ;tz4λ7w2Pλ0y3z[rs:⊂≥t2w⊂λ:42P≥yry⊗Zw:2y≤:x:εB7qqz\9W⊂⊂λ∀ P⊂→2{P$[:2y9≥x:⊂⊂~0w26→y9P⊂≥0urPλ6wy2H:40wλ⊂7w2H⊂0y3]vrw: ⊂⊂⊂)YrP:4→FE9h→qts4XP22yXy4x:~ww9W
P*42H70z:\2P7sλ:42P_y3zvYw:⊂"→x2w2≤P7w⊂≥t4qtλ⊂1t0[72v⊂≥42FE~w:2y≤:x:⊂~yP7w∞P:yzXv6<P~z⊂4yH0w⊂)Kr|89→yytw[⊂;t4Xt⊂1p[⊂12P≥yrr⊂≥7P67Xpv4⎇→P:42CE1pz\rP7sλ⊂:42H4w:2\9:x: ⊂⊂⊂)[vrP:\ry⊂4[:2y9≥x:9Pλ:yrP≥42P⊂≥0v:rH92z:\72r⊂λ1<P:~2FE9Yy;4qYP3:w_z4wwλ:7P2→qtr2H;t0zλ:7P2≠P0q7]z⊂:4→P1pz\rP7sλ:42P~w:2y≤:x:↔βEεE⊂λ⊂$w:→y9:x≥9P⊂1Xw⊂⊂1→P2tz~2y⊂⊂≤|w1t≤7w7z\P⊂∀2K3W⊂2\97y9H⊂0w2λ⊂3py_0srP_wv62Xz7yεB4w:2\9:x:≤TP7yλ0y|w_t97w≠zyP∀_ww:9≠v⊂1t_y0qz→y9V⊂_v0y6Xv7quK⊂2z1K∀W⊂⊂λ*7P8≤2{2w≥εE:4[tw3P→y97y≤V⊂0y↑w1t9≠w7zyH4w:2\9:x:≤P⊂0y→P0v;X|yP9≥w⊂4wλ∀77t[:2y9≥x:⊂⊂≥∀P6wY2WεE⊂P40w→62y⊂→7y⊂0[⊂0y|[1t97[7zyP~w:2y≤:x:⊂≠zyz⊂→|864Xtz6<H27P∀≠7tw:→y9:x≥⊂⊂74[∀P:7CE82y≠tz⊂7]42y⊂λ0y|w_t97w≠zyP2\97y9H⊂:7P~w:2y≤:x:⊂~z↔⊂⊂λ∀#7yλ2|0v\62V⊂λ:42P≤|yz2[VFE9]x864Yr⊂/1λ40w2≠2y⊂2≠ryP:~4yP⊂≤wP:4_z⊂1w[:97vλ1t0y_qz2yλ4w:2\9:x:≤P1pwλ⊂12P≥yrrεB;tz4~w⊂:4→P/1⊂_92puH67wx ∀FEεB⊂⊂⊂*~2P9r\;4qrH⊂3:w_z4ww≤P37yλ⊂6wy]⊂:yr\⊂4w:→y9:x≥9P⊂0\2P5r\:⊂⊂0\P:42H⊂;0v≥ryP7YεE9|[q7v9H⊂;tz~⊂6w2[ww4qH⊂70vYyW⊂⊂⊂P⊂64\z⊂7sλ⊂:42\rP9|[q7v9H⊂12sZw9P7[⊂⊂80YrP→VL\WεE∃42y2H0y2P_v9wPλ:yryλ4w:2\9:x:≤P37yλ⊂1ww≥97v⊂_t0y0Xz2y9K⊂⊂*4→P⊂9r\;4qrH3:w1]4ww9CE37yλ:42yYP0y2H22qv_y2r⊂≥ytw3H∀9yz_z:yP≥:<tw≥∀W⊂⊂∀rrP8_srP→K\_↔εBεE⊂⊂λ*42P~w4z4Xv⊂;0[:ryPλ37y⊂≥42P9Yy;4qYP3:w_z4ww≤P⊂7sλ:42P≥0y4w]yP⊂4[:2y9≥x:9P_y2FE≤97{4Y2r⊂1≡P:42H⊂9|y]2vP0\P192XuP⊂6≠wx9P→7y⊂9[vrP⊂~w:2y≤:x:9H0w2⊂≠4v⊂⊂→7y⊂7]42y9CE∀2|_rx:⊂→7y⊂9[vrP1[w:97[⊂1t0\0qz2\9TWεBεE⊂⊂λ*42y→P⊂0y→P⊂9w[rP⊂9\2qtp[⊂1ww≤tr2y_z4ww≤P⊂37\⊂⊂:yYy⊂⊂4[:2y9≥x:9Pλ9tsw_v62rλ1<FE_wy92Xz0q6→P⊂2y≤7y⊂⊂_ww24]4ww9K⊂⊂⊂*~2P⊂0\3zvr[:⊂:7H⊂:42H⊂9ry≥4qrPλ3:w1]4ww⊂λ4yP0CE22yXy4x:~ww⊂7Y⊂:42H2y97\⊂;t7\rP2|_qz⊂⊂→7y6P~yP22\qy4q→r⊂4wλ:42P_pz0v≠szrPλ0z⊂:~2FE2[2⊂7sλ:44yH9rqz~ww↔⊂λ$s⊂:~2P⊂9Yy;4qYP3:w_z4wwλ92z:\79P7~v⊂∀7\⊂0w<H⊂7z4→y⊂0z≠vTVεB:42P≠7y6p[⊂2y9≠y⊂89≠qrr:\2P7qXzy9P VP1w[:97vλ92z:\79P:≠P:42H6syzλ⊂92qYw:⊂"\99rj εE7yλ:7P:≠x⊂62]2v⊂$Yα there was no errcEt. If the service function retp e]LABAY%chX~)iQJA→Segh↓KYK[∃]hA←_AiQJ↓YSghASfAUgKHAQ↑ACIQK[ah↓aKG←YKerA→aP∨5π##∃↓ε+CK?⊂q↓αSF(4+↔F ∂Q↓π;πeβ&CπQ↓εKQ↓βM→βGO,∧Bαε≡4ε&/<8 M≤Y9∧
9Hλ∞M→(_l≡_;∪l@zrWλ⊂$s⊂λ92qg]2y<P~yFE)]qqr`3qful exeCution proCeads froM the poiNt where The Ep¬eODAWGGβ+CK↔ ¬bα∧≤aPG⊗\8 nl<Z(
≡h≥3N≡8xp∩\βsfu@0ACM←β##↔I∧∧W.Yx is sIdπ]CY1K@L~(~∃ K
K[EKβ⊃↓Y1β eM]α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠→5E9αEc∩α∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αααλλ⊗.
∧5S 8Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M~7α¬,Xf/⊗]l6*∧β8;N\9λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ¬∃"∀ c***
Here is an example of aAcgKβ⊃β';&+CKW¬!βO↔↔3'∂∃αβ∪G≠≤εFN}e`α¬&
≡2εO4∧π&FT
vv(Q( n↑≤≠∩,\λλ_O∀≥~→$∧≤}<nL;(→M}Hλ≥-l[x
g→⊂⊂;0\4pq6→P2y9≠y9P⊂≥t2w≥42P⊂≥yryλ27ryH77zεB9x2qZs<P'[2W⊂⊂∪4πte thatthe system-supplied error service functions consiStently
bind args to the abgument supplied. The user can check the value of this
variable to see what is wrong. Note too that the system-supplied error handlers
restore readtable and obarray before breaking.
(defun +internal-ubv-break (args)
(declare (special args))
(errprint nil Msgfiles) ;print error message
((lambda (readtable obarray)
(nointerrupt nil)
(break unbnd-vrbl))
(get 'readtable 'abray)
(get 'obarray 'array)))
(setq ufbnd-vrbl '+internal-ubv-break)
Alarmclkck SUBR 2 args
¬
alarmclock is a function fo@HAG←]QeP∨3dK;≥β&K7/,5bα∧≡@ε≡∞d∞7&∂.@αε∞l@π∂&}↓PRα∧∧απ'⎇tπ≡∂ ≡&∂&T∧π&N\Z' Z
⎇f*α
≡2ε
∧∞&.∞E↑FNnT∞FNn↑$ααG⎇
⊗≡B =w.wN4απ≡\9vv'4
v h$∧ααα ]F∂π<\Bπ&≥\RJε≥lBπ& Tε␈& ↑"εO4 ∩ε∨∞UW&N\Tπ&N\Z"αG⎇
⊗≡B∧ 6␈.nN2εn≤>&␈≡\9vv'1Q"αα∧∧ε}2
\⊗≡F≥lRαπ.]bπ&≥\RJR∧∧¬&FT fO↔>Dε∂⊗}YV.w being referred to: it may be the atom time to indicate the real-
time timer or the atom runtime to indicate the cpu-time timer.
The second argument to alarmclock controls what is done to the selected
timer. If it is a non-negative number (fixnum or flonum) the timer is
started. Thus if n is a positive fixnum or flonum, evaluating (alarmclock
'time n) sets the real-time timer to go off in n seconds, and (alarmclock
'runtime n) sets the cpu-time timer to go off in n microseconds. If the
timer was already running the old setting is lost. Thus at any given time
each timer can only be running for one alarm, but the two timers can run
simultaneously.
If the second argument to alarmclock is not a positive number, the timer
is shut off, so (alarmclock x nil) or (alarmclock x -1) shuts off the x
timer.
alarmclock returns t if it starts a timer, nil if it shuts it off.
Page 3-18 ∪3-1.4.2 December 6, 1977
**DRAFT** The System **DRAFT**
When a timer goes off, the alarmclock user interrupt occurs. The
service function is run in (nointerrupt t) mode so that it will not be
interrupted while it is performing its service. If it wants to allow
interrupts, other timers, etc. it can evaluate (nointerrupt nil). In any
case the status of the nointerrupt flag will be restored when the service
function returns. The argument passed to the user interrupt service
function is the atom time or the atom runtime, depending on which timer
went off. See also the function nointerrupt.
nointerrupt SUBR 1 arg
(nointerrupt t) shuts off LISP interrupts. This prevents alarmclock
timers from going off and prevents the use of control characters such as
CTRL/g and CTRL/b. Any of these interrupts that occur are simply saved.
(nointerrupt t) mode is used to protect critical code in large subsystems
written in LISP. A similar deferral technique is used by the LISP system
itself to protect against interrupts in the garbage collector.
(nointerrupt 'tty) prevents control characters (typed on the terminal,
or "tty") from causing interrupts; however, alarmclock interrupts (and
other asYnchronous interrupts) are still allowed8@Aβ]dA]←\5iibA¬gs]G!e←]←Uf~∀@@@AS9iKeeUaifA]QSGP↓oKeJ↓gCmK⊂AoSY0A]←n↓O↑A←→L\~∀4∀@@@@@@@!]←S]QKeekAhA]S0RAikI]fAS9iKeeUaif@↓ECGV↓←\\@↓β]rA%]iKeIkaifAoQS
PAoKIJ~∀@@@Ag¬mKHA]SYXA9←nAO∃hAae=GCgg∃H\@AQQSfA%bAiQ∀A]Oe5CXXA%]SiS¬XAgi¬iJ\~(~∀@@@@@@↓)QJAIKgkYPAeKiUe]KH↓Ie←Z↓]←S]QKeekAhASf↓iQJAAeKmS=kfAS9iKeeUah@AMiCikL@Z~∀@@@A9SXXAPXA←d↓iab\4∀~∧@@@@@A qC5aYJ@Ph(4 α↓↓↓↓α↓↓↓↓αA##πn∪∪¬↓F{3∪O& SWMHh)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓sC⊗{S↔∂&+⊃β∂|∧F+pQ$ααα∧∧ααα∧∧ααα∧∧ααα∧¬εv}≥nF/↔,X ∞D≠{→∞>_=≥.5*#"D∧λλλ∧∧λλλ∧∧
≠[m≥]→<N.<≥λ∞E*#"AQC"C!&+M F4λ⊂x.L9≠yn\(≠qD
<y0→λ$w:2\9:x:λ!t0w≠2v9FBεEεEβEεE"→qrvq→y⊂≠⊗λ_\[[H⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXW
↔→⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀0srP VX\FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP"pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c***
Each useR interrupt channeL (eXcept qome assOciated with files) has a
Varaable whose value is a functional form, the service function forthat
channel. The name of the interrupt channel is the same as the name of the
vAriable. The dollowing lists the usep interrupt channelq in al`habetical
order. The argument to which the service funcTion iq applied and the value
which it should return are described. By convention, almost all sarvice
functions receive one argument. Some user interrupts are initially sat tk a
system-supplied handler whiCh binds the var`∪C YJ@A¬eOfAQ↑@Ai!Sf@A¬eOk[∃]hAC9H~∃K9iKef↓BAEe∃CVAY=←`\@↓)QJA9C[JA=H βSF)β';&+KKWπ!β'Mπ+Oπ⊃ε EβSF)β K. %β'&+;S'6+@∩pQ!PRα∧
6}nT∞W≡∂$ ⊗w&↑.'/πN4εN>mz&*πM Rπ6≥NV*π,ZG/⊗lX ∧ ↑(∃
(≤y.∞X∧q`% function whiLe
oThers distinguiSh two cacEs* Id the value is atomic, the seRvice functionwas
not @¬EYJ@↓iP≥β⊗+∂?[/⊃β≠K}i↓βSF)β∂?v#'S'}qβS#∂!↓β∂∂+G↔⊃π##∃βL¬g&/,.Wπαd∧α∧d~:απ>≥M@hWL≥6*ε≡N2ε&\hλ.]≥λλ ≤⎇~;meλ≤⎇,=λ_<d∞Y=≥.-X∧w3H⊂1w`.trol th∞Ai!JA[←β≠Q↓β⊗+∂↔;"β↔KK≤∧W"pQ)⊗"α∞Mε*πl≥G.(λ∩.P0P⊂≠4yzελ:42Pλ1pq≠q⊂⊂:~0z⊂&~yz⊂⊂~yP:yYr⊂⊂:≠P92a[{2yλ397vH:42FB1ww2~z4wwλ:40zλ1priYr⊂:4→P⊂4w≥2y9:\:∪⊂⊂∩z⊂4yH:yzp[48 A new piece of data to Be
uSed iN place of the one that was being compl@¬S]KHACE←UhXA←HABA]∃nAM←IZ@Ai<AEJ~)KmCYUCiKH↓S\Aa1CGJA=HAiQ∀AM←e4AiQCPAKee∃H\~∀4∀@@A%LAiQ∀AmCYUJA←L↓iQJAMKemS
J[Mk9GiS←8AmCe%CEYJ↓SfA]%XAS]MiKCH↓←L@A∧AMk]
iS←]¬X~¬M=aZXAQQJAkMKdAS9iKeeUahASLAG←]MSIKe∃HAi↑↓EJAiUe]KH↓←ML\A)QJ↓gsgi∃Z@AE∃QCmKLACf~)SLAi!JAMk9GiS←8AQCH↓ek\A¬]HAe∃ice]∃HA]S0\~∀~(@@A'=[J@AUgKd@↓S]iKIekaiL@ACe∀@ACge]GQe=]←kfAS\@↓]CikIJX@A¬]H@A¬eJ@A∃qKGkQKHAS8~∀Q]=S]iKIekah↓hRA[=IJAi<AaeKYK]hAQS[S]≤AKee=ef\@↓)QJA%]iKeIkahA!C]IY∃`A[CdAGQ←=gJ~∃Q↑Aek8AS\@!]←S]QKeekAhA]S0RA[←⊃JXAQ=oKmKHXACf↓iQJA%]SiS¬XA=D↓QC]I1Kd@A⊃←Kf\A)QJ4∃]←S9iKeeUahA[=IJ@A%fAeKMi←eK⊂@ACMQKdAi!J@AQ¬]IYKHASf@↓ek\\A'kG @AS]QKeekAifACIJ~∃i!K[gK1mKfA⊃KMKeIKHAEd@Q]←%]iKeIkahAPRA[←⊃J\~∀4∃C@3∂∪7∂3}≠ ~α∧∧ααα∧∧α¬4~)∀ ∀HQPPh*Mε*πl≥G.
xbε∞L≡&n≡M|6@4~<h∞M→(≤l↑]Z0lT→];L>~;sD [|@∞M→(≥.<<H∩-n→<\N↑≥λ∀m≤{X;
L9β"N⎇→;@ ∀≥~;,↑H≤y.Dλ≥<∧ ↑(∃
(_; ≡[8s
|zh→N]X⎇~-⎇Hλ→m|<h≠l@3↔⊂⊂∃42P0\3zvr[:⊂⊂4\β the
fame of the timer which went @=ILX@↓iS[J↓←d@AIk]iS5J\@AQQJ@AIKike9KH@AYCYkJ↓Sf~∃%O]←e∃H\@@↓)QJ@↓gCem%GJAMU]GiS=\@ASL@AKq∃GkiK⊂AS\@QU←S9iKeeUah@APR@A[=IJ\@↓)QSf4∃S]i∃eekaPASfA%]SiS¬YYbAQke]K⊂A←ML8~∀
∀4∃Cki=YWCH@@@@@@@@A-β%%β¬→
4∀~¬)!J@Am¬YkJA=H@ACUi←Y←¬HASfAiQJ↓gKem%GJ@A→k]Gi%←\AM=`@Ai!JAkg∃`@AS9iKeeUahAo!SGP~)ae←m%IKf@↓Cki←5CiSFAY←C into the environment. The
Page 3-20 ∪3-1.4.3 December 6, 1977
**DRAFT** The System **DRAFT**
argument is (function-name . autoload-property). The returned value is ignored.
See page 3-26 for details. This interrupt is initially set to a function which
simply loads a file.
cli-message VARIABLE
The value od cli-message service handler for the user interrupt signalled when
another job has interrupted the LISP job via the CLI device. The argument is
nil and the returned value is ignored. A usep handler is expected to open a
file on the CLA device and read the message from the other job. The service
function is run in (nointerrupt t) Mode. This interrupt is iniTially turned
off. Currently, it exists only in the ITS NeWio implementation.
errset VARIABLE
The value of errset is the service function for the usep interrupt which iq
signalled when an error is caught by an errset and *rset is non-nil. The
argument is nil and the returfed value iS ignored. This usep interrupt is
initially off. Turning it on affects the behavior of the error system (see page
3-16).
fail-act VARIABLE
The value of fail-act is the service function for the user interrupt which is
signalled when any of a large variety of miscellaneous error conditions occurs.
The argument is a list whose first element is generally a symbol which describes
the type of error condition. The rest of the list contains various objects
related to the error. The returned value depends on the error. These are not
standardized and will not be described here. This interrupt is initially set to
a break loop.
gc-daemon VARIABLE
The value of gc-daemon is the service function for the user interrupt which is
signalled after each garbage collection. The argument is a list of items; in
the PDP-10 implementation each item is of the form (space-name fpee-before
free-after size-before size-after) and in the Multics implementation, each item
Iq of the fkrm (space-name fRee-befkre . free-after). The returned value is
ignored. This inteprupt is initiallq TurfeD off.
¬
December &, 1977 ∪3-1∞4.3 Page 3-21
**DRAFT** MacliSp Reference Eanual "*DRAFT(T~∀~(~∃OF5Y←gg¬OB@@@@@@@A-βI∪β¬→∀~∀
∃QQJAm¬YcJA=HAOF5Y←gg¬OBASLAiQJ↓gKeM%GJAMU]GiS=\AM←HAiQJ↓kgKd↓S]iKIekahAoQS
PASf4∃gSO9CYYK⊂AoQK8AiQKIJASf↓]↑A[=eJACYCS@3∞∪3∃β∞#∪K↔∨→βOC∞≠∃β?∩β←#↔pβS#∃¬#'7∃¬≠#πKNs≤4*n{;'S␈⊃βK↔T+∂SMε βK↔∂+↔OQ∧3?Iβn{K∃βn+7?KJq↓α'rβS#∃∧kW3SN≠@~ε≥↑εf.\]g&∂M≥vrb∞Mε/⊗QQ&O~ ≥G>∂≡4αε.mx
,⎇λ≠9-]|↑+∧∞{hλ∞M~<h∞↑y<@
≥]→<N∞<≥λ∧
Y=Y.⊂7qq]y9W⊂λ$w⊂⊂≥42P(⊃(∩XXβE0vx≠2vrg≥0z4w[⊂:42H0y3z[rs:⊂~yP:4→P70vYP7s⊂≥42P9\0qrP≥40z lkst, and the returned
Value is iGnored. This interrupt iS iniTially set tk abreak loop.
gc-overflkw VARIABLE
¬
The valqe od∧AOF5←mKe→YWnA%bAiQ∀AgKeYSGJA→k]Gi%←\AM=` βSF)βWO-⊃β';&+KKWπ!β←#L≠!β'_h+O'>sπ33.!β←#.qβ¬β∨βπ∂∃ε{[↔K6c?←MεKSMβ>≠7πar↓↓#O.)βπ3f{
βπv!↓#O& SWMε;∂7πBI9%α&C∀4+∂∪∨W7,sQ↓βO→↓βSF)β;πn)↓β?2↓βS#*βOCπ≡)1↓↓¬##∃↓π∪↔SW⊗s↔⊃β6 3W∃αβ'M↓εK↔;?⊗+⊃9↓¬##'LhS';S/∪KWC"β'MβNs'S'∞c3eβ≡+QβSzβ¬β ⊗+π-βf{?A8hP4(4VK=73␈≠Oπ∨*↓↓↓↓α↓↓↓↓¬2εJ& ∩2∀4Ph*S#*β[π3.)β?→εK=73␈≠Oπ∨*β'Mβ&C∃βO/∪['∂*β≠W;∨#'?9ε3?Iβ&C∃βW≡+Iβ'w#↔KK/βQ↓β>C'∂!εKL4+≡K∨;πfc↔⊃β>C↔9β&C∃α%|yβOg∨#↔5β.s∂?Ww#↔KMε 9β↔↔∪?I↓F3?Iβ/Cπ7Cf)1β¬ε3'3∃π;#'∂Bβ←πLhS ↔'v9β?C.s↔⊃β> Mβ;␈!β≠?.s⊃%9ααS#∃ε K∨Wn+;QβO→β¬βfKOQβ}1βS#*β;π7*β?→β&C∃β≠.s∂S'}p4+←FK∂!β/∪K↔⊃αβπ;⊃εKSMβ∂∪∨W7.sSM1αβ←#'≡Aβ7πJβ#π[*↓β ↔.qβOS∞s∪πK&Kk↔⊃αβ?Iβ␈##↔K>KO∀4WβπKSN 33eε#'∨↔∨#↔⊃9ααS#∃π∪↔SW⊗s↔⊃β6 3W∃εKMβ¬εc'OQε{→β¬εs↔]β6{K5β&y↓β *β↔[πg+πS↔ h+'9πβ3π∂*β?→β&C∃β∂∞c1βSz↓βS#*β≠W;∨#'?9π;#'∂Bβ↔KK.!9↓α&C'MβNsS↔K↔+CQ↓εKMβ'vKS'πfcd4+≡+QβSzβ¬β ⊗+π-βf{?A8hP4(4Vkπ∂#Ns∃7↔↔∪?I↓α↓↓↓↓¬2εJ& ∩2∀4Ph*S#*↓β[πg+∃↓β}1β7π≡C';∃n+KK?∩↓β'MαβS#∃αβO↔K6K∂∃βF ;∪3/⊃↓β≠␈⊃↓βSF)↓βW≡+Iβ'w#↔KK/βP4+≡K∨;πfc↔⊃β>C↔9β≡{7∃β&K≠≠'∨+3SeεKMβ↔Gβ↔K'.s∂↔⊃ε∪eβSF)β#?∨!β7π≡C';∃r↓↓αSF)βO↔↔3'∂∀hS≠W;∨#'?9π∪↔∂↔O3↔Mβ6{WIβ∂∪∨W7.sSMβNsOS↔∞!β?→ε{;∃9ααS#∃ε3'KO"β'Mβ∞q↓βπ&{7'
π≠g7 }`4+'v#'∂π&K;≥β&C∃βSOβ∃β?2β↔KK␈⊃h4(hQ↓↓β/3π1↓α↓↓↓↓α↓↓↓↓αβ'33.;π1βn ∂#'v)β?C/∪πS'}p4)↓αβ↔cπnK;∃↓α↓↓↓↓α↓↓βπ'#↔7C"βS=β⊗+≠↔K.s∂∃βv{97↔FKOS↔w!β7↔n{Kd4R↓↓β∪/β?O'"↓↓↓↓α↓↓↓↓ε SS↔oβQβSzβ←K'&)β';&yβK↔∞!7?;gIβ7↔n{Kd4R↓↓β?&#A↓↓α↓↓↓↓α↓↓↓↓πβπK''Iβ↔K⊗{H4*&C∃β?&C↔Iβ&CK↔∃ε K∨Wn+;SMε K∃↓ε3'c;.kMβ←FK∂!β∂∪∃βπ&#K↔O≡+Mβ?2↓β7↔n{Keβf{∂πSN{;M8hRS#∃π≠↔∂?v!β'Mπ##∃βf{∂πSN{9β?2↓βS#*β↔KK␈⊃mβSF)βS#O∪⊃β'~βS#∃πβK?∨⊗ 5↓β≡{W;S/⊃β←#.p4(4Ph*Cπ>)↓M5∪⊃↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓M~iE9Qs→↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αα∪↔∂.k ↔Iβ11↓EK9\4(1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓αS#*αOgO&+5↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4+SF)β↔K⊗{Iβ?≡≠WKK.!m↓β∞s⊃βSF)β≠?/∪S!↓εKMβSF)α*B~↓#S#*↓βCK};Kπ5ε≠?W;&+Iβπ~↓β?→π##∀4VcπOQεSW7AεK;OS↔+∂S'}qβ ↔6{K∃β&C∃β↔↔∪?Iβ}≠∂WK⊗+⊃%9ααS#∃εkπ∂#Ns∃7↔↔∪?IβF ;∪3/⊃β7πHh+O'>sπ1β
β∪'≠6+K↔;"β/';"β?→β/∪K?Iε{I⬬s≥βG.KQ↓#≡+∃βSF)α{≥ε3W;∂&K?9%αβ'→β&+O'K.!04+␈⊃β↔;&+I↓β
β K↔∞Yβ3?␈↓9↓↓¬##∃β∨+ Iβ7+;∂SN{9↓↓G≠↔∃βε ∨∃↓~iEAMJ↓β7πJβ ∃↓π+O↔≠.aβ'8hS∪↔∂}#';≥αβS#∃π##K↔*↓β≠'FsW5β∂∪∨W7.sSM9α↓α'→π##∃↓εCπ;∪f+IβK/#WK;~a↓βSF)↓β[∞cW∃βO_4+'>s?K↔"↓βπ;"↓βS#*β↔KK}s↔?W~↓β?C/∪πS'}q↓β'~↓βK↔'∪'↔⊃r↓α'→αβS#∃αβWO↔∩↓βCK␈3'∪↔~β;<4Vkπ∂#Ns∃7↔↔∪?I↓εCπ;∪f+I↓#&C∃↓βNsS↔K↔+CQβO→↓β'vKS'πfceβS/∪;↔⊃αβ?≠→JaβS#*↓β↔K⊗{Iβ'led in the default manner for the host machine. On ITS, this puts the user
in DDT. This currently exists only in the PDP-10 Newio implementation.
Example:
(defun machine-error-handler (type loc pc jpc)
((lambda (args terpri)
(declare (special args terpri))
(terpri msgfiles)
(cond ((eq type 'examine)
(princ '|;REFERENCE TO NON-EXISTENT
MEMORY| msgfiles))
((eq type 'deposit)
(princ '|;WRITE INTO READ-ONLY MEMORY|
msgfiles))
((eq type 'eval)
(princ '|;ILLEGAL MACHINE OPERATION|
msgfiles))
((eq Type 'odd`)
(princ '|;MEMORY PARITY ERRLπ%x~(@@@@@@@@@@@@@@@@@@@@@@@@@@A[MOMCY∃bRR~(@@@@@@@@@@@@@@@@@@@@Q`⊃↓GβK';~↓∨qn,r.:><qα6ε≤B&:∃∧*JJ>↔`4)↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓β7≡;≠'3/→%%$hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αCCKπv→↓∨Q∧2J>5∧b6∞ε$J0≤@H∨λ
↑yyZ-L<j#!∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ¬∞≤Z3L4≤_j!QHλλ∧∧λλλ∧∧λλλ∧∧λλλ∧¬≤≤Z-lh ␈∧ 3H⊃JYβ!`∀ILπ⊂→βbβ7O∨4¬⊗f/5⊃PBα∧∧ααα∧∧ααα∧∧ααα∧∧αGπ-→c
αα≤u,.H≤⊂e∃ εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀1≤2pu@≠pqt4[2Vri≤αh∂dR$~∀@@@@@@@@@Q1SghAβ#gC∃∧¬F}~∞λλd
\_j!QHλλ∧∧λλλ∧∧λ≥∀JFAεEβE0
ar-breAhε@@@@@@@@A-βI∪β¬→∀~∀4U##∃β4 3@.Tλ l@⊂6py q92`Zβ ic phe q` e@4¬⊗≡(~_-l≠→0→λ30∂r↓iQJAβ+G/$∧εNwLX N8¬pt↓`∂'∨v 3 &\AP@.z→0↔λ842Pλ4rvw\αy l@=GCiSα{9βO∧∧V≡Nm_ ,Dλ_↑$¬≤|p~_z:yP≠py∀Pλ∀9r`% page 3 ~@K9%↓βF Eβ ,∧Vph!Q hTLXλl]8Y0→λ≠⊗⊂_NY[P⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂ YKXW∩↔ P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂( YpP⊃VL→FEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP&pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*¬
εEεEβE0qqYyyrrλ4w⊂:~2P9x→qts4Yr⊂6p[72y↔λ⊂*42H0y3z[rs:⊂~yP74[⊂0w2λ:42P≤2z:i≠2r⊂;_v:rP~yFE4Yw7y2Y↔⊂⊂⊂∃42P9Yy;4qYP⊂3:[1z4w[⊂4yPλ9:w~w⊂⊂∀≠7tw:→y9:x≥⊂:∀Pλ6wr2K⊂⊂⊂ [9wV⊂∪$ihεB4vx6~qtz6≡P82y→7y6yH∀9yz_z:yP≠py⊂_λ74v∀H12s7\2P9:[74w3H:42P≥yry⊂λ4w:2\9:x:∞P:44\FE42[89P:≠P892]2w:⊂λ4w3$[4z2P≠7wx9K⊂⊂*4~yP4w≥2y9:\:⊂⊂4\P4w4]4pv6≡P::y≠2r⊂⊂≠s3↔⊂λ$zεE_zy92[:6<P→|4yz≤P7w6≡P⊂4wλ:42P∩h)P'→{twPλ4vx6→vrw:_z4ww ⊂)rrH80srH→VZ[λ⊂37iλ6wy2CE4w3≠y6pz~ww⊂7[⊂:yt[3P:4~yP4w≥2y9:\:↔εEβEεE8→6⊗w{→y367]P⊂⊂⊂λ⊂⊂⊂+⊂i$`a∪"FEεB*42P≥0v:rH7s⊂8→6⊗w{→y367]P4yPλ:42P≤ry;4XrP3:[1z4w[⊂37yλ:42P≥yry⊂λ4w:2\9:x:λ;t4qZεE4yH9tsw_v62rλ;t2wλ⊂0P(≥yt27]w⊂64\z⊂2|_rrr9H⊂4z9H8266X|↔⊂⊂
9rrP_v67qH⊂0w2λ∀9z0]:yFE≤266p↑∀W∀P∃42P⊂_y3zfYw:⊂$\P⊂:4→P9x0Xrw0vYP⊂7sλ:42Pλ8:yt→7{w⊂≠4yz↔λ⊂⊂*4→P92z≥y72bβE;0v≥pP4iH4sw7\2r↔⊂λ*44yH4w:2\9:x:λ4yP4[4z4p[6<P)Yz⊂:7H0P19→puP6≠wx↔εBεEεE≤|yVr→pz4⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∃ i$`P&"FEβE*42H;0v:YP7s⊂≤|yVr→pz4⊂~yP⊂:~2P9r\94qrH40w2≠2y⊂3≠y⊂:4→P:yr\⊂⊂4w≥2y9:\:⊂9tYw0v6→rεE;Z2w⊂:~2P:4[rVyt_y0w3H⊂9|y]2vP4\P0q7]z⊂⊂:≠P3wP→7{w⊗λ⊂40yH12rgλ92{4]2r⊂⊂→97vP≥40zεB9z0z→V⊂7yλ⊂4yP_2tw3H22q:Ysrrπλ⊂⊂*4→P0y3]vrw:λ⊂4yP≠4v⊂ [2⊂⊂:~2P92]8y72Y⊂⊂;0[:rP4\FE4s[7y2r ⊂⊂ Pλ:yryλ40w2≠2y⊂⊂≠p|P;Zyt⊂⊂≥5P2|_vtw2H⊂:42H92yz[:⊂⊂7Y⊂∀9z_z:yPλ4z9TH:7FE→2z2y≠tw2P≥42P9]0z2P≠s⊂:4→P9|y]2vW⊂λ*42P≤ry;4XrP3:[1z4w[⊂4yP≤:w⊂⊂~w⊂∀7≠tw:2\9:x:βE:∀P≠wr2Wλ⊂*44\P4w:→y9:x≥⊂4yP~w4z4Xv6<P≥:y72Y⊂7s3 ⊂⊂*4~yP1z\92w:≠<P2|~yz9P≠w6<P~wεE:~2P$j∀P'2{ZwP4v\62vr[:0z4[w↔εEβEεE:≥<Vy2]:y7⊂λ⊂⊂⊂⊂λ⊂⊂⊂+⊂i$`a∪"FEεB*42P≥0v:rH7s⊂:≥<Vy2]:y7⊂~yP:4→P9ry≥4qrP~0w26→y⊂37\⊂:42H:yryλ⊂4w:→y9:x≥⊂9ts[0v62YεE;t→w⊂1w[:97vλ7s⊂:~2P:2\6tw0[⊂4yP≤2z:y≠2r⊂:≠P:42H&$ihλ57q⊂_<P4z≤P⊂9z\2y4w\↔⊂⊂*~4yFE_v67{\P&$iT⊂:7P→2z2y≠tw2P≥40z⊂≥42P2~yx60↑P9qy→rw⊂6X|P40]2P12Yw⊂1t_w3rrλ⊂1<P≠z42yβE57q≤W⊂⊂⊂∃42P0\3zvr[:⊂⊂4\P74vλ⊂0w2λ:42Pλ92z:\72r⊂≥0v:rH⊂4yP~sw7y→r↔⊂⊂λ*42P≤ry;4XrFE3≥w1z4[w⊂4yH⊂9:wλ4w⊂∀≠7tw:→y9:x≥⊂⊂:∀H6wr2K⊂⊂*4~yP⊂4[:2y9≥x:⊂4\P⊂4w~z4pv≠<P::\72rεB7s3↔λ⊂*44\P1zy≤2w:6≡P2|4\z9P7[6<P4[⊂:42H$j)P∪2{twH4vx6→vrw:_z4ww εEεEβE:w1≠2⊗{9_6⊂⊂⊂λ⊂⊂⊂⊂λ⊂+ i∩`a&"CEεE*~2P;0[:rP7Y⊂:w1≠2⊗{9_6⊂4yH:42P≤ry;4XrP3:[1z4w[⊂37yλ:42P≥yry⊂~w:2y≤:x:⊂λ;t4qZ⊂4yFB9tsw_v62rλ;t2wλ0w⊂0]:2vx≥⊂⊂4yH6pr2H:7P2]0v:p]2P⊂0[⊂0z7[tqP9↑vq7vλ;t4qZ⊂⊂27YyP77]εE40]2P0P≥0v:rH∀0w⊂≥w17z[2⊂;0\4pq6→W∀P⊂∃42P0\3zvr[:⊂4yH0P64\z⊂7sλ:42Pλ9|vq≠v⊂;t~qtεEβEεE(_srP→KY~⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXW
↔→P⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂"2Xrvq2\⊂≠⊗⊂ \[[FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE1wz[2⊂77]⊂⊂12H2{0v≥pz2r ⊂⊂*4→P⊂92]:y72Y⊂;0v≥rP4yH⊂0P6~yz⊂7Y⊂⊂0P≠2{P9↑vq7vλ⊂:7P_2FE2]0v:p]2r⊂4[⊂4z9H860qYW⊂⊂*~4yP4[:2y9≥x:⊂4\P4w4]4pv6≡P9rzλ:7P0H192pZP67w\↔εEεBεE:w→3⊗s7_z7⊂⊂λ⊂⊂⊂⊂λ⊂⊂+ T$`a&⊃FEεE∃42P;_v:rP≠s⊂:w→3⊗s7_z7⊂4\P:42H9ry;~qrP3≥w1z4[w⊂37\⊂:42H:yryλ4w:2\9:x:λ⊂;t4Xt⊂4yCE9ts[0v62Y⊂;t2[⊂0w⊂_z:2v\:⊂4yH6pr2H:7P0\86<P_w⊂:w→2s4w→r⊂3:[1z4w[↔⊂⊂⊂∃42P0\3zvr[:εE4\P0P6~yz⊂7Y⊂:42H3:w1]4ww0[⊂37y≠P;t4Xt⊂1w]v2⊂7≠z⊂12H0x86~rr↔⊂λ*42P≤2z:y≠2r⊂;_v:rFB4yP⊂_P64y]⊂⊂7sλ0P⊂7→{P⊂3≥w1z4[w0v⊂→7y6Pλ:7P:_urP⊂~z9P8≠0qrWλ⊂⊂*4~yP⊂4[:2y9≥x:⊂4\FE4w~z4pv≠<P9r]⊂:7P_P192XuP67[x↔εEβEεE:[9rrw swVz_sP⊂⊂λ⊂⊂⊂+⊂i$`a∪"FEεB*42P≥0v:rH7s⊂:[9rrw swVz_sP4yH:42P≤ry;4XrP3:[1z4w[⊂37yλ:42P≥yry⊂λ4w:2\9:x:λ;t4qZεE4yH9tsw_v62rλ;t2wλ⊂3wP≠y⊂:4≤7{P4\P⊂:yYr⊂;t]4⊂0P≥0sP⊂≥t4qtλ27ryH77z⊂→|4yzλ⊂4w⊂≥42FE_zy92[:⊂89≠sP17Y<P7yλ4w⊂0[<P1p]1t⊗⊂≤2yx2Xz4{2[<W⊂⊂∃42P0\3zvr[:⊂4yH0P64\z⊂⊂7Y⊂:42CE2y9≠w2wz\P:0sK⊂⊂*4→P92z≥y72rλ;0v:YP4yP_P⊂64\z⊂7sλ0P72]P:0sH:7P9→x60qYP⊂4z ⊂⊂*4~yFE4[:2y9≥x:⊂4\P4w4]4pv6≡P9rzλ:7P0H192pZP67w\↔εEεBεE;y≠3Vw7Kpy3yH⊂⊂⊂⊂λ⊂⊂+ T$`a&⊃FEεE∃42P;_v:rP≠s⊂;y≠3Vw7Kpy3yH4yP⊂≥42P9Yy;4qYP3:w_z4wwλ37y⊂≥42P:\ry⊂⊂~w:2y≤:x:⊂≥t4qtβE4yP≤tsw0[62r⊂≥t2w⊂_P3:w_z4wwλ4yP1Xv62rλ;tz4λ:42P≥y7w3H7:vq→y⊂7sλ⊂0y3]vrw:≤W⊂⊂*~2FE0\3zvr[:⊂4yH0P64\z⊂7sλ:;wP~z2vyN⊂#4y≤z⊗⊂0H64yzλ7s⊂:~2P3*[1z4w[⊂0w2λ:42P_y3zvYw:9FB:40zλ;ry2H80yiYr↔⊂⊂∀rqww→⊗⊂:4→P⊂60[q20V[4yz⊂~s⊂:4→P3:w_z4wwλ;pyPλ4w:2\892z→r⊗⊂7\εE:4→P9pvYP27z≥2r⊂8_ty⊂0\P0y3\P92z≥y79P~s⊂:4→P3:w_z4wwλ;pyP_wvx4[2r⊗⊂≠y⊂:4→P0z7[P∨FE~s⊂:4~yP4w→7y6p]4ww⊂_wzv2λ77z⊂_2P22]2y6t[2r↔⊂λ*42P≤2z:i≠2r⊂;_v:rP~yP0P≠4yz⊂λ7s⊂0CE72{H⊂37y≠P⊂:7H12P⊂→{0v:Xz2rλ4w⊂8≠0qrPλ7s⊂⊂≥42P6≠ytw3H⊂7w2K⊂⊂⊂*~4yP⊂~w:2y≤:x:⊂~yFE$[4z4p[68P)Yz⊂:7H0P19→puP6≠wx↔εBεEεE≥y73V]<x2VXy3P⊂λ⊂⊂⊂⊂∃ i$`P&"FEβE*42H;0v:YP7s⊂≥y73V]<x2VXy3P4\P:42H9ry;~qrP3≥w1z4[w⊂3'\α the useR interruPt which
is sienalled when an argument is passEd to a system function whiCh is no`(is a list of the argument which was
not accepted. The returned value is a list of a new argument to replace it.
That is, directly an argument, not a form to be evaluated to get an argument.
This interrupt is initially set to a break loop.
December 6, 1977 ∪3-1.4.3 Page 3-25
**DRAFT** Maclisp Reference Manual **DRAFT**
*rset-trap VARIABLE
The value of *rset-trap is the service function for the user interrupt which is
signalled when an error returns control to top level, just before the bindings
are restored. By convention, the handler for this interrupt should not do
anything unless the variable *rset is non-nil. This is so that the user will
not be bothered unless he has put LISP in debugging mode. The argument is nil
and the returned value is ignored. This interrupt is initially set to a
function which enters a break loop if *rset is non-nil.
There are other interrupt handlers which are associated with I/O files or
inferior jobs. See eoffn, endpagefn, (sstatus ttyint), and create-job.
1.4.4 Autoload
The autoload feature provides the ability for a function not present in the
environment to be automatically loaded in from a file the first time it is
called. When eval, apply, funcall, or the version of apply used by compiled
LISP searches the property list of an atom looking for a functional property,
and fails to find one, it looks for a property under the indicator autoload, and
it it finds one, automatic loading will occur.
Automatic loading is performed by means of the autoload user interrupt; thus
the user may assert any desired degree of control over it. When the autoload
property is encountered, the user interrupt handler is called with one argument,
which is a dotted pair whose car is the atomic symbol which is the function
being autoload'ed, and whose cdr is the value of the autoload property. The
system-supplied handler for this user interrupt could have been defined by:
(setq autoload
(function (lambda (x) (load (cdr x)) )))
From this one can see that the value of the autoload property should be the name
of the file which contains the definition of the function. Note: in the TOPS-
10 implementations the system autoload handler presently uses fasload rather
than load because the load function requires the Newio feature. This affects
the form of an autoload property.
When the interrupt handler returns, it should have put a functional property
on the property list of the function being autoloaded. If not, an undf-fnctn
error will occur with a message such as "function undefined after autoload."
Page 3-26 ∪3-1.4.3 December 6, 1977
**DRAFT** The System **DRAFT**
Examples of setting up functions to be autoloaded:
In the Multics implementation:
(putprop 'foo ">udd>AutoProg>Library>foo-function" 'autoload)
In the PDP-10 Oldio implementation:
(putprop 'foo '(foo fasl dsk me) 'autoload)
In the PDP-10 Newio implementation:
¬
(putprop 'foo '((dsK me) foo) 'autolkad)
¬
or (putprop 'foo 'tdsk:`≠JmMW↑A→CgYx@OCKQ←Y←C⊂RA←dAiQJ↓≠YIS<@AmKIcSO\↓CYg↑4∃g←e-f\
∀4∀∩∀~(~∀
∀4∀∩∧~(~∀
∀4∀∩∧~(~∀
∀4∀∩∧~(~∀
∀4∀∩∧~(~∀
∀4⊂∩∧~) KGK5EKd@XX@br\h
↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓MMk 0∪"d@λ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧
_9y$εhεP∩7
**DRAFT** MacliSp ReFerence @≠C9kC@1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓%(E∀ h@
E!"C"AQL+@~H⊂"2a≥pπgiNe
~∀DX U9λ↓α πv#';≥bαC∪1¬β?'≠&+CMDλλ-lλ≥~ T⊃=P⊂[8¬adop∧⊂∀λhP4)↓ααS#∃∧kπ∂3M≠Aβ↔4 3Gπ&{@∩α
_ d X<p∩Y⊂7w a pUqh down @1Sgh@!aIXR0AWd@↓ciCG,XAoQ%GP~∃!←YIfAE@'v#';∨~a↓β↔4 3Gπ&K?9β4ε&∞n↑5Bαε≥lBαπ>]f'↔∀ ⊗wε↑-f∞b∧λF∂&∃`λ∧∧⊂Z3LM;Y|d <Y#!.X;≥,↑h≠qD =≠{-≤hλ≤o≥8[{∞P;t4Xt⊂0y→P⊂9p]2r⊂;Z2w⊂:~2P⊂9↑vq7v≤β are use@⊂@ACf↓YCKE⊃B~∃m¬eSCE1KfXAAe←NAYCe@'∞∪3↔Mbβ?I↓ε#=β[∂∪'π f+E9↓∧+[π∪. S'?rβ∪Kπn+M↓β∂∪∃β∂}sOSK,≠S↔⊂hS←#↔pβ¬β;|q7πS}k'
β6{K5βM→β↔[∞cWπS.!↓β?∩β←#↔rβπCCgIβ'Mπ+O↔⊃r↓αS#/I↓β∂⎇∪K↔Oε{;⊃β&x4+≠.s∂S'}qβ∂πfcE84Ph)↓↓∧ MβSF)β↔[∞cWπS␈⊃βK↔∨+KO'6+3eβ-3π3W∂#↔Mβ
β≠?Kjaβ';4{K7π&K?9βM→βCW≡C↔⊃β|sS=β&C∀4+ε#1βπv!β3π&+IβC␈βC↔⊃ε{≠→9αα←#↔rβS#∃αSKO↔"βπ;⊃∧s?WWzβ≠3π?→βπK*βQβSFKMβ'v3?K7∂#'?8hS'Mβ∨+≠≠'≡K↔;SgIβ∪↔& '3↔ ↓βS=ε∪∃β?2βWO∃αβ'9β&+ W∨>K;≥9α↓"O↔*βS#∃αβ[πKN 3↔~↓+KO/ 4+πv!β;?/+=β'rβS#∃εs↔cQπ≠↔∂SN{99$hP4)↓αα¬βC␈≠'S'}qβ←'&C'9β&C∃βC&aβ7πJβ ∃βv 7↔⊃ε∪eβ7. ;Mβ}1β¬↓↔β∪1βε{';S/⊃ 1↓π;#'∂Bβ'L4V ↓β;.;πS'6)↓β≠OC;W5π;#?O*↓β[πg+∃↓βF Mβ7. ;';:↓βS=αβS#∃ε+[π3. S?Ir↓↓β;Na↓β'~βπ3Oxh+π∂≡+CS↔"βπMβ
βC∪1πβ?';&+ImβO!β7↔∞sM↓β&C∃βS␈↓β?→π##∃β∨#π∂-bβ%;∃rβS#∃αβ7?O"βK↔∂.sP4+/3π3W∂#'?9r↓α;?&)βS#∂!βS#O→β'Mε#'≠≠/∪↔;Qε3K?5εs'1β∂→β¬β⊗K;∪'v9↓β∂|sS↔c"βC?'w#↔I0hS←#'≡Aβ7↔∞sM↓β&C∃β ␈#S?5ε{⊃↓β&C∃βO& ∂-↓ε{AβSF)β?W&+K7?∨!↓β↔epted as a pdl pointer; it designates the frame at the bottom of the stack.
Pdl pointers may be used as arguments to several debugging functions described
in the next section. Since the fixnum value of a pdl pointer has only internal
meaning, generally a pdl pointer cannot be obtained from user input, except by
the user typing in a pdl pointer chosen from a list of pdl pointers typed out at
him. The "frame" functions described in the next section may be used to obtain
pdl pointers.
An important thing to note about pdl pointers is their limited scope of
validity. If the information on the pdl which is named by a pdl pointer has
been popped off since the pdl pointer was created, the pdl pointer no longer has
valid meaning.
1.5.2 Functions for Debugging
Page 3-28 ∪3-1.5 December 6, 1977
**DRAFT** The System **DRAFT**
*rset SUBR 1 arg
(*rset x) sets the *rset switch to nil if x is nil, or to t if x is non-
nil, and returns the value it set it to. (See below). This function
exists primarily for user typing convenience.
*rset SWITCH
If the *rset switch is non-nil, extra information is kept by the
interpreter to allow the debugging functions, such as baktrace and
evalframe, to work. In addition, the interpreter will make extra checks
such as checking the number of arguments passed to a subr or lsubr and
checking that array subscripts lie within the declared bounds. Generally,
the *rset switch being on means "I am debugging"; this is known as "*rset
mode". The initial state od the switch is nil.
nouuo SUBR 1 arg
(nouuo t) sets the nouuo switch.
(nouuo Nil) turns off the nouuo Switch. (This is the initial state.)
nouuo returns t oR nil according to whether it turned the nouuo switch
on or off, (See below.) This function exists primarily for user typing
convenience.
nouuo SWITCH
If the nouuo switch iq on, function calls made by compiLed functions to
compiled functions op∧@AgegiKZAMk]
iS←]LACeJAM←e
KH@AQ↑@AO<@AiQI←kOP↓iQJ~(@@@@↓S]iKIaeKi∃dAKC
P@Ai%[B\@↓)QSf↓CSIfAS\A⊃KEkO≥S]N\A∪L@↓iQJA9←kk↑AgoSQGPASL~∀@@@A←M_XAoQ%GPASLAiQJ↓]←e[¬XAGCMJX@A
←[aS1KHAG¬YYfA
C\AE∀A[CI∀Ai↑@↓O↑AI%eKGi1rP~∀@@@A]QSGP↓SfA[UGPAM¬giKd8~∀4R↓↓↓↓α↓↓αSF)β;?-+=βO>KS∂!εkπeβ⊗)βSW⊗s↔⊃β|3⊃βπ βπ;e¬#'7∃p↓α↔π≡A↓β∂|¬WεNL\Bε7]l7&N⎇aPRα∧∧αε≡≥MBπ>≥MBε}mK∩ε>t∞FG⊗|XvBπM RεNnLWππ,ZF/∩
x L<(≠;n +λ⊂.D≥z~,=λ≥~-\αP⊂4]⊂;tf≠∧@
be linke` directly( @A%LAiQ∀AG←[ASYKHαβ∂?∪*β#πM∧∪↔↔→¬∪↔3?∞#↔↓βL¬g&Z∞Mε*π?~7&.QQ"αα∧∧π>OMπ&FT
¬-∀T wπ&≥⎇bαG<XRπε≤|Rβ~β( J
P:42[⊂:44\P24`2ect Linc may be qfsNappeD
and the I`≥i∃` CK,εF/∩∞-w/&T
&*N↑:F∞⊗M~6F.D∧ε↔J¬∞7∨&≤¬≥.P⊂:j[v4w5\TW⊂⊂⊂2qpz\p@
λλ
*&+∂π↔⊗+@∩βeDβ Kvpλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f5,+E%@→⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂(_qrP→KY_
**DRAFT** Maclisp Reference Manual **DRAFT
*
the PURE option requires an amount of extra space and time, it is not
normally on; thus links snapped in code loaded as non-PURE cannot be
unlinked.
The trace package turns this switch on when a function is traced, in
order to ensure that tracing will work even for compiled functions.
Compiled function calls which have been "snapped" to go directly do not
push debugging information in *rset mode and cannot be traced. See also
(status uuolinks).
baktrace LSUBR 0 to 2 args
baktrace displays the stack of pending function calls. It gives
detailed information only in (*rset t) mode. The first argument is a pdl
pointer, as with evalframe. If it is omitted, nil is assumed, which means
start from the top of the pdl. The second argument is the maximum number
of lines to be typed; if it is omitted the entire stack is displayed. (The
second argument is currently permitted only in the Multics implementation.)
The information printed by baktrace is not the same as that obtained with
evalframe; both should be used to get the maximum amount of debugging
information.
baklist LSUBR 0 to 1 arg
baklist returns a list containing the information which baktrace would
print. (This is available only on the PDP-10 implementations.)
errframe SUBR 1 arg
errframe returns a list describing an error which has been stacked up
because of a user interrupt. The list has the form (err pdlptr message
bcp), where pdlptr is a number which describes the location in the pdl of
the error, message is a list of from one to three things which, given to
the error function, could have caused this same error, and bcp (binding
context pointer) is a number which can be used as a second argument to eval
or a third argument to apply to cause evaluation using the bindings in
effect just before the error occurred.
The argument to errframe can be nil, which means to find the error at
Page 3-30 ∪3-1.5.2 December 6, 1977
**DRAFT** The System **DRAFT
*
the top of the stack; i.e. the most recent error. It can also be a pdl
pointer, in which case the stack is searched downward from the indicated
position. Thus if there are recursive calls to the error handler, the
second error back down the stack may be found by:
(errframe (cadr (errframe nil)))
The argument to errframe may also be a positive number, which is the
negative of a pdl pointer. This means start from the position in the stack
marked by the pdl pointer and search upwards.
If no error is found, Errframe returns nil.
errprint LSUBR 1 to 2 args
errprint Treats its arguMent The same as errfraee. The secOnd areumeNt,
in Newig ImpleMentation only, is the file(s) Into Which to print the
inf@=aSCi%←\@@!gKJ@↓aeS]PRP→↓ααS#∃αβ7/><⊗>
∞
wπε≥⎇bαε|dαπ& Tαε/.-wαα n&∞nT
↔λh$∧ααα∞
&Nv4|V"r∧ Wπ↔∞-⊗w"∧∞&/'↑-g
πD
⊗ $λ_
\αyypYpP⊂+XyP:<\2r⊂']z⊂⊂ [2⊂74[⊂⊂4`& ng
erro@HAMeC5JAoCLAMOkαs⊃8∀Ph $ -3π3≠⊗ 7¬↓α↓↓↓↓α↓↓↓α≥*αI↓λ∧ε∂⊗qQ hR∧∧ααα∧∧¬&FT ↔⊗?]\Vw"∞Mrε/l≥F .X;9$
<hλ ∀≤→≠∧∞≠z3NL<Kλ ≡h≥z.Mλ→4N \X;,Uβ⊂⊂⊂∃42P(→6εE⊂λ⊂⊂⊂ )pεAgKα @⊗≡ X ∧∧→[p→λ0p∞ evalUatioN h∂LAα ↓β≠,s∂S'|qβ∂πd¬Bbα∞X m≥Yh⊂~~2P⊂)XvrP 2ules
λ∧@@@ACE←β+Q↓β≤εF∂↔M_ L@P87`)np @¬]HAI%` ↔∂&K?9↓∧∧↔4→<\L@90vrH⊂:y`%pεP→↓αβ↔[πd∧g,8εrP_v;p|\β
α s@-SafAα{[↔I∧∧⊗wJ 8λ-Mα9P 4o idself @QQChAαKQβ≠L¬f'~
→bπε Tπε&EaP@@ ¬⊂⊂λ⊂⊂⊂⊂λ*42P≥0p `+∀ASfA∧AQSgP@QiSββ∃βC&cCCI∧∧f␈⊗β(⊂⊃_x⊂ , where pp∪Aα)β'M∧∧W6∞βλ⊂↔\α a`@AYrX~(@@@@↓aIYaQ` β'~β¬βC&aβC?LsS↔I∧εFzπM Rε/l≥G.∂M→vrε≥`π&FT∞7&∞=1Bπ∨]~F∞⊗LTε&@|H⊂~\pP0yCE⊂⊂⊂λ⊂0w argu@5K]hAβ#=↓β,εf∞fn,⊗n
x D <XYN 99(
}Hλ_L≥⎇≤X,<+λ⊂∪≠y2P$\β the fo@IZAEK%]N~∀@@@A∃mCY@. S↔⊃ε{A↓β
β3'O"↓β?→¬##∃↓εsπ7∃ε{⊂∩α∞Mε*εnYf∨&≥⎇bαε,Y⊗v: ≡πεf≤\Bαε≥lBπ& QPRα∧∧αε∂,}Vn.β]≤d
=λ⊂≠XyP0x≤64rrλ:7V⊂_w2⊂1_x⊂4iH0P14[24w3H1ww:→|:⊂8≠tw:2\⊂;t4Xt⊂1p[εE⊂⊂λ⊂⊂12H8yrbλ;tz4λ2{0vλ:7P"]0r2p]2P9w[pz44[3P4wλ:42P_4w24[3P1w[:2|:λ⊂5:y]⊂12s≠y2FEλ⊂⊂⊂⊂≥42P2]0v:p]4ww⊂→7zw2λ1<P"]0v39_vrWεBεE⊂⊂λ⊂⊂⊂⊂λ2{0v→90vrH92z:\79P7~v⊂4sλ77P2]0v:p]4ww⊂_pw⊂1→P37z[2↔εEβE⊂⊂⊂λ⊂⊂⊂⊂→{0v3≤0rrP≠w6<P≥wy5yH4w⊂∀
99rzλ:∀P6[r2V⊂≤tw1rH77P2↑890P→90vrH4w3'\6pz4[wεE⊂λ⊂⊂⊂4\P9p{→r⊂7z~2y;t\rWεEβEεE"→qrvq→y⊂≠⊗λ_\[[H⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXW
W→⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀0srP VYXFBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP&pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*¬
εEεEβE392]:y7⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂)ja∀⊂→⊂0\3yFEβE⊂⊂⊂λ⊂⊂⊂⊂
392z≥y7⊂8λ<∀P⊂≤2z:y≠9P1w[:97vλ:7P:~2P⊂2]0v:p]4ww⊂→2yts[0z2rλ1<P⊂≥42P8→6εE⊂λ⊂⊂⊂8≠tw:2\⊂8⊗⊂_w2⊂3≠y1ryH4z⊂⊂≥7P92]:y7⊂≡↔⊂⊂*~4yP⊃≠7w⊗v≠qpv⊗Ywz7Qλ⊂3:w_z4wwλ1pwεB⊂⊂⊂⊂λ12P:\rr⊂:≠P27P→0w1|H92qw]2y<P→97vP→y97y≤WεEεBεE2{_v47wZP⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂+ T$`a&⊃FEεEλ⊂⊂⊂⊂λ⊂⊂$sλ:42P≥0v:rH7s⊂2]0v47[uP4yH77w⊗[:v6⊗λ:42wλ9x2qZpv⊂:~4w3yH40x8→w⊂⊂4[⊂:42CE⊂⊂⊂λ⊂2{0[:pz7\↔⊂⊂+Z2w⊂⊂_P37y≠P⊂∀2]2w⊂0[⊂0z7[TP⊂4\P:7Pλ12P2]0v:p]2r⊗⊂λ2{0v~7wuP~yFE⊂λ⊂⊂⊂1≠zw2⊂≥7P74[⊂0w2λ:42P→:w1z~ww0vλ37y6H;t4qZ⊂;pyH4z9P≥0v:rH4yP0\864rY⊂⊂:7H7w2FB⊂⊂⊂⊂λ0y3z[rw:⊂ P:42H37y6H:40zλ;pyP≥9<tw→P:7P_2P2{_v:pz→r↔⊂⊂∃42P;_v:rPλ4z⊂9→z:y7≤FE⊂⊂λ⊂⊂4yH:42wλ92z:\72r⊂→97vP≥42P⊂→{0v:Xz7y↔λ⊂*44\P32p]:y2P~yP:yYr⊂1<H⊂:42H)z2x≤2yεEλ⊂⊂⊂⊂≤0qupYrP22\qy4q→r⊂60]2y⊂4[⊂:44\P9rq]4ww↔βEεE⊂λ⊂⊂⊂⊂λ⊂2{0[47wuH4yP1≠zw2⊂≥7P74[⊂1<P_92puK⊂0w2λ9rz8Irr⊂:≠P74vλ1<P2\97y9H⊂:40]⊂3wFB⊂⊂⊂⊂λ10quH:7P:≠x⊂62]2v⊂⊂_w2⊂8≤4w:⊂
↔⊂⊂*~4yP⊂≤97{4Y2yP:~2P0q~v4z<H:7P⊂→yqpx→P397[FE⊂⊂λ⊂⊂:4~yP6wY2P4sλ9wvr]44w3H10r⊂~0x82[9WεEβE⊂⊂⊂λ⊂⊂⊂⊂∩w⊂7y→2y⊂7≠z⊂:7H4vx0Zy⊂⊂:~2P2s→4qtr[1|P7Y⊂:42H&$ihλ⊂4w:→y892]2y⊗⊂≤r{2y_vεE⊂λ⊂⊂⊂9→yz94Xz4ww≤P⊂0y→P4vx≠yrr⊂λ7w⊂2]0v47[uW⊂⊂λ$z⊂7[6<P⊂_x864YyP:7H⊂2{0[:pz4[w⊂⊗FB⊂⊂⊂⊂λ;t2z~2y⊂4[⊂⊂0P≤2pr⊗Y{0v⊗\94w:λ67wx ⊂⊂4w≥2y70[6<P4[⊂2{0[:pz4[3P⊂0\3zvr[:9P4[εE⊂⊂λ⊂⊂37\6yV⊂≠y⊂⊂1≡P2|8≠4qtzλ⊂:yrH7s⊂⊂≥42P3≥w1z4[w⊂⊂2]0v↔⊂λ$z⊂⊂→7ryP≠7z⊂⊂~0{2P_w<FEλ⊂⊂⊂⊂→s32q]⊂7w⊂_wvx4[2r⊂3≥w1z4[w⊂92Y2y2w_ryV⊂≠w⊂:yYP7s⊂≥42P3≥w1z4[w⊂0x≤6<V⊂≠y⊂7wβE⊂⊂⊂λ⊂:42H⊂⊃6p\84w3H⊂3:w_z4ww≤W⊂⊂⊂⊂v9wVλ0yP⊂_P9x2Xtpv⊂λ1pyrK⊂:42H⊂0y9_|P92Y2y2w_rFE⊂λ⊂⊂⊂;Z4qt⊂λ4yP⊂≥42P⊂→4y9zλ0y3z[rw:⊂λ:7P⊂≤z7y2H⊂4yP≠2{2yλ⊂9rr[⊂⊂1<H⊂:42H2{0v~7wuFB⊂⊂⊂⊂λ3:w1]4ww≥H47{r]2y⊗⊂≥42P9]q2|8≤2yyt[w9P7Y⊂:42H0y90↑P92s→y2w1YP⊂∀:~2P4w→4qryJFE⊂⊂λ⊂⊂;t[6⊂12H9rrw ⊂⊂∀*~4yP9\2qtp[⊂:92Xz6rw≥⊂0{7Zr9P0H897q≠2vP;Zz4⊂:~2P⊂;X|P9z≠y2FEλ⊂⊂⊂⊂≥wy5yK∀P'7\6pv6≡P⊂:4→P2{0[:pz7\⊂27r\P⊂77]⊂1t2XuP:4→P⊂;0[:rP7Y⊂⊂2{_v47wZV⊂4wβE⊂⊂⊂λ⊂7y2→y⊂:7H⊂9p{→P:4vYW⊂⊂*≠P⊂6pZrP4zλ1t2qZV⊂⊂<[zP6z\z⊂17]4⊂⊂1→P4w⊂
∃99r]⊂⊂:∀H⊗FE⊂λ⊂⊂⊂2→q:ssZw3P⊂ P⊂6wY2V⊂⊂λ0w2⊂λ40{2H⊂27w→P⊂⊂∀≤yz0z≥yP⊂2]0v47[uP⊂:
W⊂⊂⊂λ'7z⊂λ0v6εB⊂⊂⊂⊂λ4vx6→vrw:_z4ww≤P72rY⊂⊂17]4⊂7sλ:47yYV⊂⊂1≥z⊂<w]P9t7]v2⊂⊂_v;p|\P27P_7z4⊂λ:7P1→FE⊂⊂λ⊂⊂9z\2W⊂⊂∩s⊂<w]P⊂:yYP:42H)z2x≤2y⊂⊂≤0qupYrV⊂<[zP72Yr⊂⊂7≠z⊂;w\9<]P~z⊂⊂2≠ryP:~4yFEλ⊂⊂⊂⊂_zz7vXz4qp[6<WεBεEεE→{0v4≠wuP⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∪)ja)λ→⊂7yλ→P0y→yFEεB⊂⊂⊂⊂λ⊂⊂⊂∀→{0v4≠wuP⊂→7y6P~7wuTH⊂4yP_P⊂3:[1z4w[⊂;t4Xt⊂⊂4→v89P→|867Zz⊂⊂:~2P2{_v47wZFE⊂⊂λ⊂⊂32Xz:y2K⊂⊂⊂*~2P⊂3≠y6P⊂~yP⊂2]0v:p]2r⊂⊂≥tz4⊂λ2{0v~7wuPλ60vq→0Vq7]w2⊂⊂λ:7P⊂≥42FEλ⊂⊂⊂⊂→:w1z~ww0vλ⊂37y≠P⊂47[uW⊂⊂λ*42Pλ1t2qZtw3Pλ7s⊂⊂→{0v4≠wuP⊂~yP⊂1≡x0yyYr⊂⊂4[⊂:42CEεEεB(0srH→VYYλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂ YVLW~W→λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂⊃2qrvX2y⊂≠ ⊂_\[MFEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂λ⊂2{0[:pz4[w⊂⊂7Y⊂37i≠P⊂4z≤rv3⊗λ⊂1:jλ77z⊂λ4w⊂0[<P⊂9]q9tb~py<Pλ2{0v≥pz4w[9V⊂#≠yεE⊂λ⊂⊂⊂4[9z0w_rP⊂7Y⊂⊂0y→zvrw≥9P⊂4[⊂⊂:4→P37y≠U⊂⊂⊂∃44yPλ4yP⊂≠4urPλ0P⊃7[2Vtw≤z9:q]4wwεB⊂⊂⊂⊂λ897qYrr⊃⊂λ4w⊂⊂_P⊂6pXt4w2Kv0w3]psrP→2q:sYry↔⊂λ⊂$s⊂λ0v6⊂λ:492YP⊂0y→zvrw≥9P0y→FE⊂⊂λ⊂⊂89→yrw: ⊂:42H9rqg[2⊂4yH0P14[24w3H1ww:→|:⊂8≠tw:2\⊂0w2λ4yP:\rr⊂0\P⊂:4→P9rq[w2εEλ⊂⊂⊂⊂_y3zvYw:⊂*≠P2{0[⊗⊂0w→⊂:42H:44y→⊂0y3]vrw:λ4yP:~2P47[uWεEβE⊂⊂⊂λ⊂⊂⊂⊂⊃|0vx≠2]εEβEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
22s*[⊂47wZP32|≤9⊂∀<
P⊂⊂⊂λ⊂⊂⊂⊂λ⊂≥qp[62r_yP∀4≠ (prog2 (sstatus evalhook t)
;magic sstatus
(evalhook (car x) 'hooi-function)
;evaluate form
(sstatus evalhook nil)))
;more magic
t))
¬
(defUn hook-function (f)
((lambda (terpri)
(decLare (special terpri))
(princ '|form: | msgfiles)
(prin1 f msgfiles)
((lambda (v)
(terpri msgfiles)
(princ '|value: | msgfiles)
(prin1 v msgfiles)
v)
(evalhook d 'hook-function)))
t))
;this is how to eval the
; form so as to hook
; sub-forms
The following output might be seen from (hook (cons (car '(a . b)) 'c):
form: (cons (car (quote (a . b))) (quote c))
form: (car (quote (a . b)))
form: (quote (a . b))
value: (a . b)
value: a
December 6, 1977 ∪3-1.5.2 Page 3-33
**DRAFT** Maclisp Reference Manual **DRAFT**
form: (quote c)
value: c
value: (a . c)
(a . c)
The following functions only exist in the Multics implementation.
baktrace1 LSUBR 0 to 2 args
baktrace1 is the same as baktrace except that binding context pointers
suitable for use with eval and apply are displayed along with the function
names.
baktrace2 LSUBR 0 to 2 args
baktrace2 is the same as baktrace1 except that pdl pointers, suitable
for use with baktrace and evalframe, are displayed along with the function
names and binding context pointers.
Page 3-34 ∪3-1.5.2 December 6, 1977
**DRAFT** The System **DRAFT
*
1.5.3 The Trace Package
The LISP tpace package provideq the ability @Q↑AaKIIWeZ↓mCeS=kfAC
iS←]LAChAQQJ~∃QS[JA∧@AMk9GiS←8ASfA
CYYK⊂@AC]⊂AChAQQJ@AQS[JA%hAeKQkeMf8@@A)!SfAG¬\AEJAkgK⊂AM←d4∃ieC⊃SiS←9CXAiICGS]≤A←dA→←dA[=eJAg=aQSgQSGCi∃HAIK kOOS9NACGQS←]f8~∀4R↓↓αSF)βSK∞≠∃↓βε ∂/π>)β'Mαβ;?QπβπKQε{⊃↓β&C∃β'vKS'πb↓β↔;6KK/;n+;QmεC?←↔6+I1↓εKQβ'_h+πW&{7πSN≠π33J↓β3?∞#↔⊃βLq↓β?rβS#∃αβ≠'K≤εBπ⊗\lW⊗.l8RαπMtπ&FT∧ε7.l:FN}d∧π'⊗≤<R`$
∀y,Q"X=.M{≠x,EJ#"AQHλλ
M→(∪ ~tλ≥∞ 8y(∞ 8zx,|(_smnz<⎇∞∀≠yH∞M≤Y9$
8:;D ];XnM;{\eD≥≤X,<+λλ∞]]≤X,<+λ⊂-lβ"\L]=≤X,<+λ⊂-Mλ≠qD∞z~8m∧_<Y$ Y>≤∞.kC"AQHλλλ∀_x;
D≥≠h∞NX8q$
_<h∞M→(→M⎇≠≠um≥Yh→M}[(
εB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀:90XpP:9_qro`3pecs)
¬
A trace←spec intqrnis eItheran atkm (the name Od∧AiQ∀AMk]
iS←\↓iV@A JAie¬GKHR4∃WdA∧AYSgPp∩∀@@@@@@@@@@@@@@@@@QMk]
iS←\5]CKJ↓←aiS=\bA←AiS←\H@\\\$~∀
∃β;#↔K*βS#∃ε{CS'}sMβπ⊗)βπM∧3?33␈;Eh∀Ph+ K. %βC⊗+⊃↓↓α↓↓β∂∂+O↔Mαβ¬β ⊗+π-↓ε ≠S↔∩↓βCKLsS';8∧π&FT∧ε.wN/∩π',≤6*α¬
⊗2α ≥gJJ .W hαHλ∧∧λλλ∧∧λλλ∧∧λλ_L\[|Y$ <≤≠∂≥9Y`∧∞~→(∞NX8y,Dλ→]-l⎇~;md≥≠h∧
=≤h ≡Y⎇3,]]≤k∧∧~9H ≥Yβ"D∧λλλ∧∧λλλ∧∧λλλ∧
{[≡$
9H≤∞,9λ→.l;≥8.L<h≥
t≠[sE]Z; AQA"Pm⎇Yλ≤∞,9λλ∧∧λλλ <=<y.∀≥≤X,<(~3Lm|[8.M;{H∞Mh_Y$∞≤Z;NL9λ→M}H→]-l⎇~;md→;]∞/(_;LE{|C!$λλλ∧∧λλλ∧∧λλλ∧∧→>~.D~9H ≥Yλ≠mm≡(~,D≤≤Y,D→=X-N8=→.4≥≠h
m{K;M≥ C"AQ]z→.,:;H mHλλ∧∧λ_x.↑y<h∧∞~→( n;X⎇
≥{Hλ∞Mhλ_LT≥≤X,<9λλ
⎇[≡(∞⎇→;H∧ x;≠ \λλ→N-{(≥
#"H∧∧λλλ∧∧λλλ∧∧λλλ∞>→8z,m99λ n;X⎇
≥{H→MeHλ∃
(≥<l↑H_x-d→z=LT≤y=L↑X;λ∞NX8y$∞|→8n4≥≠c!$λλλ∧∧λλλ∧∧λλλ∧∧≥≤X,<+λλ ≥≠λλ∞>→8z,o:;Yd∧≥~→$∞x;9$∧→];L>~;{D∧_]=∧∧≥z=
∧→~9Ll<Y;NA"Hλ∧∧λλλ∧∧λλλ∧∧λλ≥m <Y:-d≠|≥
≥{\k∧∧≤{h∞M_=λ∧∞~→( n;X⎇
≥{Hλ
≡h≥≤L≤y9λ∧
;H→
≤YY<L]]β"D∧λλλ∧∧λλλ∧∧λλλ∧∞x><d∞z→;D x;≠ \λ→\M⎇(λ→
≤YY<L]]λ→N]X⎇~-⎇\kH∧ [⎇→$∞~_=∧
9Hλ mH~<aQHλλ∧∧λλλ∧∧λλλ∧∧λ_;∞,89≡$ Y:;Ltλ≥≤L≤y9λ
≡≤y; eλ≥~ Tλ≥z ↑Y:;D
|≥~-⎇Hλ≤∞-xX8MO(≥z-Mβ"H∧∧λλλ∧∧λλλ∧∧λλλ
m⎇λ≥m}Zh_.4→→<m≡Y9 D∧
∃~ ]H_9l≥;Kλ
≡λ≠:,⎇≥ J$∧∪[u T≥~_.Dλ→[D
8>#!$λλλ∧∧λλλ∧∧λλλ∧∧≠[⎇∧ Y(_$ {{<
≥→9λ n;Xu
≥{KC!!"X<L}→≠λ∞ ≠λλ∧∧λλ≤n 8z9M≤<h_-d_=≠mT≤→≠∧∧≥z≠n<(≥X-N9(≥∞ 8y(
≥Z=~,≥≠≡(∞<=≤h∧∞≠h≠M≥ C"D∧λλλ∧∧λλλ∧∧λλλ∧λ(λ≠
≡⎇λ≠lDλ≥~ T_⎇<N,;]λ∧∞Y8⎇..z;{D
→=Y-Dλ→[n∧≥~→$∧→];L>~;{ED≥~→!QHλλ∧∧λλλ∧∧λλλ∧∧λ→]-l⎇~;md|h≠L≥9+λ ≥Yλ_$
~<⎇∧
yH≥
(_<L};9;NNh~<d {{\d|9λ≠mn≠h≥
#"C!!"Q→,<;8Y.$
Kλε↔-mh∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f5,+M%fhλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∀ ≤y( eVm#"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~<n∧∀Y9L↑Y;XlT∪8;N\;λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1U
E!"C"AQHλλ∧∧λλλ∧∧λλλ∧∧λ≤→
D≥z→-d≥~→$ ];XnM;{H
≡hλ→-n→<Y,Eλ_;LD_y≤D|9λ_L≤zh≠llHλ≥m ;H≥
#"H∧∧λλλ∧∧λλλ∧∧λλλ n;X⎇
≥{H~.4→>~.L9 H∧
~→(∞ ≠λ_l≥H_Y$
;\| \⎇→9∧ \[{$ (_\L\:|≠m≥] β!$λλλ∧∧λλλ∧∧λλλ∧∧→[|D >_;.
→+λ ≥Yλλ∞↑y9λ∞Mh→→.L<[:-l(λ≥
(≥Y./(≤Y,<;]λ∧
~<⎇
}↑(≠la"Hλ∧∧λλλ∧∧λλλ∧∧λλ≥
(→]-l⎇~;meHλ∃
<h≠n∞~;{D∧_x;D Y(≥.<9λ≥m≡~λ≠n$λ≥z.M≠⎇=∧∞≤Z;NL9β"D∧λλλ∧∧λλλ∧∧λλλ∧∞≤X8lT≠⎇=∞∞= H∧λ88z∧∧→];L>~;{D x;H ,(→z.l;Hλ
≡≤h≠n⎇H≤→
Eλλ≠n$≠{Y!QHλλ∧∧λλλ∧∧λλλ∧∧λ≤→
D≠8>$∞y<]LT≤y=L↑X;λ n;X⎇
≥{\kAQC"Y-n≤↑(
M<⎇λ∧∧λλλ∞>→8z,m9<h ∀≠~<nD≠yH ≡XZ=∞,<↑(
59>≤∞,<|z-⎇values are to
be printed along with the usual entry-trace. The list of
resultant values, when printed, is preceded by a \\ to separate
it from the other information.
exit list similar to entry, but specifies expressions whose values are
printed with the exit-trace. Again, the list of values printed
is preceded by \\.
arg that the function's arguments, resultant value, both, or
specify
value are to be traced. If not specified, the default is
neither
both Any "options" following one of these four are assumed to
both.
nil arbitrary S-expressions whose values are to be printed on
be
both entry and exit to the function. However, if arg is
specified, the values are printed only on entry, and if value,
only on exit. Note that since arg, value, both, and nil swallow
all following expressions for this purpose, whichever one is
used should be the last option specified. Any such values
printed will be preceded by a // and will follow any values
specified by entry or exit options.
If the variable arglist is used in any of the expressions given for the cond,
break, entry, or exit options, or after the arg, value, both, or nil option,
when those expressions are evaluated the value of arglist will effectively be a
list of the arguments given to the traced function. Thus
(trace (foo break (null (car arglist))))
would cause a break in foo if and only if the first argument to foo is nil.
Similarly, the variable fnvalee will effectively be the resulting valua oF
the traced function. For Obvious reasons, this should only be used with the
@∃qShA=aiS←8\~∀~(@@A)!JAie¬GJAgAKGSM%GCiS=]fA[¬rAEJEMCGQ←eKH8D@A
=`AKq¬[aYJ0~∀~∀4∃!CO∀@fJ@≠1↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓M~iE)Uq→↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αα∪↔∂.k ↔Iβ11↓EK9T4(1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓αS#*αOgO&+5↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4)↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓G#Kπ∂*↓!#≠}yβ π∩Iβ←#/∪↔'9ε∪πiβ6 3W∃JH4(4VKMβ↔∂+'[πf+;Qβ&x4(4R↓↓↓↓α↓↓↓↓α↓↓#S⊗ ∂∃↓F3?=β>C↔K↔Nqβ πRβ[π3.)%↓#⊗ Iβ←F+K↔'rβ πiπ3π3W*I$4(hQ↓↓α∞c1β?/#CWQπβK';&+⊃β JβSKπ≡)β∂πrβ ∃β?∪?W;"β';Szβπ9βLs∪↔;&+⊃1↓π∪↔π∪∞∪3∃β6{K7π"`4+ JβO'7εceβO/#S';:βS#∃π3πK'∞∪3∃↓π≠CK'w#↔Iβ&yβQ9ααO↔S&K;≥β∨βK';&+IβSz↓β;'bβ∂#πv;↔L4W##∃β⎇+SCW"β π∂Z↓βS=π+O∃β&C∃↓β␈∪∪';∂∪eβC⊗K;Qβ7+;∂SN{91↓π;#'∂Bβ'Mβ6 OS↔∩↓βπ;"βWO↔_h+3↔∨→βOS␈∪π∨∃ε∪WQβO→β3↔∨→βK↔∞#π 3*β≠?IεcπK∨*β3'O"βOSK.≠SWK/→84(hP4)↓α↓↓↓α/Cπ7Cd+Mβ?2βS#∃π+O∃β}1βSK∞≠∃h4Ph)↓↓α↓↓↓!
IαS=π#Kπ∂*β≠W;∨#'?9ε3?=1¬βK';&K;≥β⊗{S!β∂∪∨W7.sSMβ}qβ↔;'∪eβπv!↓βK/≠W3Qε{84)α↓β↔cO!h4)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓#'∪π∂∃ε3?=$hP4)↓α↓↓↓β␈⊃↓#S⊗ ∂∃↓F3?=%Jβ?I↓G#Kπ∂*↓#≠?zβ ?SBI%84Ph)↓↓α↓↓↓!∩IαS=αβSKπ≡)β≠Wv≠S'?rβ≠?=αβ?;3Jβ←#↔rβ∂π3f+⊃↓β7∪?5β5+;∂SN{9β ∂⊃1↓β∞s⊃βSF+84)α↓β?;gIβ'→αC∂∪IπA%β'~β;'1Ph)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓G#Kπ∂*↓#≠?zβ←#↔⊗+'9β⊗ Iβ∂|s⊃↓#w+31↓F≠∪IβBI%%$hP4)↓α↓↓↓β␈⊃↓#S⊗ ∂∃↓F3?=β≡{;⊃↓FsW31αC∂∪IπA%%β>C↔K↔Nqβ π∩I$4(hQ↓↓α∂→βS#M→β↔c∞kC3∃π≠#?←~aβS#*↓β?K&+Iβ?2βS#∃ε{CS'}sMβ7∞[↔Mβvy↓β∪N3≠↔K.s∂∃1ε+c∂↔π 4)↓αβ≠?Iε K≥1π3π3W*aβ ?&A1β?∩β;'1bβ←#'≡Aβ7W∨!β ∃εcπOQph(4)α↓↓↓↓αAM%α&yβSK∞≠∃β≠.s∂S'}qβGW/A1βC⊗K;S'v9βS#*βK↔O.cSπ;"β[π3.)β?9ε+c'SNs≥β /!β;<hQ↓↓β∂∪∨W7,sSMβ}qβ↔;'∪e!βπ∪';SNs≥↓β&C∃β[∞cW¬β}1↓#∂∂⊃↓βaJβ?9β,sSKebβ?→↓ε3?=Ebβ≠?=∩`4)↓αβπ;⊃αC≠?=~β πIJβ?9β,πεO"Dλ⊗v"
|bπW >f⊗vT ⊗v"¬∞↔>/.O∩π≡∞,Fg*∀
vrε-}FBα ]g'↔∀ ⊗v Q$ααε←
↔#PQ!PRα∧∧ααα∧∧ααα∧∧ααGN,⊗≡*¬∞↔//∧ Vw'/∀αBF<≡"πB∃∀ε/F≡DαF6⎇v∩ε6⎇v"αFm⎇s~ε,≡"JHQ$ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααε-}FBπ/ 76⊗mTαG∂|↑''J∞=π⊗&NU∩JHQ!PRα∧∧αααεE∩α¬Mtπ'⊗≤<Rαεn]f∨&≥⎇bε6⎇tαε}mO∩π> ]bαε<≥Ff.D 'Jα nVv∨M≥vw~ ,↔∩α ≥f"ε,∨"`h$∧αππ-≥g&Nlpε∂⊗}4ε}r Yg'↔∀ ⊗v"∞,W∨.NDαε}d WFOEDππ⊗≥nFNvt∞FF*∞l⊗g.T
v"α¬∞↔//∧ &∂⊗aQ"αα ,↔↔ε¬∀ε}r ←εO" n&}j ivzα∞⎇ε.r 8⊗ff\@ε↔J ,↔Rε⎇mGJB ≥f"α =vv&≡M⊗}v≥MGJε.,V∞↑≥lphR∧∧π>F]dε≡∞MLV"ε/∀ε⊗∂$
⊗"ε∀λW∂.≥N2ε∪!Q hPQ!PT&\8Vn⊗↑$β2bε↔∪;:∧∧ααα∧∧ααα∧∧ααα∧∧αα↓65S
sUf2αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αα¬ ≤v*β5V38h bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jA"Ph!Q hPQ$ααα∧∧ααα∧∧ααα∧¬π'⊗≤<RαFm⎇rπ> ↑&.Nd &∂∩ .&.∞4¬ε/∂\≥Bε
!∩Hh$∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αF6⎇tπ>F↑,VNr ,↔Rε←
↔"α¬∞↔//∧ &∂⊗d &∂↔
↓∩JJ⊃Q hR∧∧ααα¬εRJ¬Mtπ'⊗≤<Rαεn]f∨&≥⎇g~π
vzε≥lBε7UDαεv↑lWαπ∞-⊗w&≥lrε∞o≡FFNlpαε6}$ε.OM W∩`Q$ααε.ZBπ≡≡i⊗v: ≥Fbε≡,w.n]nG~εmz"ε⊗}Mαε}d ∩ε≡⎇]V}r∞ Fbε<≥Ff.D f}␈ MBbε≥lBε↔,\⊗↑NlqPRα∧
⊗w≡≤LRπε
⎇rεNd∂αεO4
fNc!Q hR∧∧ααα∧∧ααα∧∧ααα∞N&∞≡T¬πεF⎇tε∂⊗} Fbεm⎇wε&D '⊗.≥4αFw]MBπB∀λ6}vD
fNb
m⊗bHQ$ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααFnTε∂⊗} Fbεmywε&D 6}vD
fNb
m⊗bJ⊃Q hR∧∧ααα
Mε*α,=vv"
m⊗b∩∧∞π⊗/lYg'~ ≥gO&
≥f:ε≡@ε∞fD∧ε7⊗⎇Tε⊗.≥lrππ-≥g&.Edαα¬M Rπ≡\9vv Q$ααεm≥BεNd V∞≡∧∧π'⊗≤<Rπ∨ \2π∨ \6N6≤↑2απM ↔"εmtε∂⊗}4ε␈∩∧∞f∞g\Tε∂⊗T∞Fzα ,Rππ-≥g&.G1PRα∧ ⊗g&
}V>B∞Mε*ε=⎇f"εm≥Bπ>}]F"π∞,W6.nDπ&FT∞π⊗NnMw/" ≥gO>∨∃Bπ∨ \6N7≥≥f:α∞MεO~∞Mvxh$∧αππ,↑f.wN4π'⊗≤<Rε7-⎇Rε/lX D∞y=≥
≥Yh≥.∧≥~→$
98z ≥Z<s.4≥≠h Mh≥~
≡kC"AQHλλ∧∧λ≥≤L≤y(∀L↑≥<[N4_<h
≡≤hλ∞l;≥9$ (≠~.>λ≠yD∧≠X;,↑h≠yD ;≠λ n;X⎇
≥{\h∧∞≤X8l\∞h→M}C"H∧∧_;↑$ ];XnM;{\d∞≤X8l\λ≥z.Mλ≥~ T≥z→.,:;H
}≥~;meλ≤x/∀
≥≤L≤y(
m{hλ∞⎇→<Y-≥H_X.%*+β!$λλ~-n⎇→8,D≠yH∧∞Y=≥.-Z;Yd
]<⎇∧∧→[{d
=λ≤L↑≥<[N4λ_(ε5;~<nDλ
→M⎇h≥z ↑Y:;D∧_X<E∃Hλ∩,a"Hλ∧∞≤X8lT→Z;LNh_(∞NX8y$∞|→8d
=λλ My<{D}λ≠~-<+λ~-n⎇→8,D≠yH∞M→(→N]X⎇~-⎇I|h∧
X;9$
=β"D∧λ≤Y.N<[\d (≠~.>λ≥z
}y(_l≡H~<dπhλ_-lλ≥z
}y(_lNH~<d ;H→..[|H
\<|x,|+Hλ∧
~→( ↑\[|AQHλλ
\<|x,|<h_.,.C"AQJ∂h∞⎇→<Y-≥H→[mu(λ≥∞,8y( =⎇;→
d⎇λ→M≥Yλλ ≥H→>∞∞Kλ→L←≤≤K∧
|H≠,≤|[h∞∞[|→..≡(λ m|H≥
#"H∧∧λλλ∧∧λλλ∧∧λλλ n;X⎇
≥{H≤n 8z9M≤9λ_O∀≥~→$∞z→<L];H≠n∞~;{Ea"C"Eπh_<L}→≠λ m{j(∧
~→(∧
=→;$ [{≠
}z;Yd∞~→( ≡Y|→
Dλ≠|∞M;{H∞|<h≠M}λ_(∧
[{K-m;λ_.M{:8aQHλλ∧∧λλλ∧∧λλλ∧∧λ≤}-\[{ AQC"Jπt→[{d∧≠[⎇∧ ];XnM;{J$∧∩;Y
≤x=→.4λ≥~ ≡λ≥~ T→];L>~;{D∧≤|→,=9Z9,D≥≠h ,(λ≥∞,8y9∧∞x<c!$λλλ∧∧λλλ∧∧λλλ∧∧≠[{E\=≠{-≤kλ≠n$λ~_,D≠[h∧ ];XnM;{X-D≤≤[n <]≡%dλλ
l;~9∧ ];XnM;{X-A"Hλ∧∧λλλ∧∧λλλ∧∧λλ≤∞-|→<NM9<h ≡Y(→/∞≤Kλ l>≤≤ED≤⎇8N%λ→\n\\Kλ
N⎇8\ED_;Y∧
88|MuJ#"AQJ∂h m{j(∧∧λλλ∧∧λ→[mt~<h
m⎇λ_$∞X;~,D≠|≥
≥{KC!!"Hλ∧
~≥<d (≥<lT≠yH∞NX8y$∞⎇8z∧ <c"AQHλλ∧∧λλλ∧∧λλλ∧∧λλλ¬∞e (foo wherein (nil)) (bar argpdl nil))
would Return, without setting up any traceq,
((? wherei@8@Q]S0RR@P|ACeOAIPA]%XRR~(~∀
∃ACGJ@LZfp@@@@@@@@@@@@@@@@@@@@@&fZb8j\f@@@@@@@@@@@@@@@A ∃GKKE∃`@lXbrnn4⊂_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@↓∪LAs=j@ACQiK[aPAi↑AMaKGS→r@Ai<AieC
JAB@↓Mk]GQS←\A¬YeKC⊃rAEK%]N@AQaCGK⊂XAie¬GJ~∃
CYYf↓k]ie¬GJAE∃M←eJ↓gKii%]NAk@AiQJA]Kn↓ieCG∀X@A∪_AC\A∃ee←d↓←GGkIfX@A
CkgS9N@P}4∃g←[∃iQS]≤RAi↑↓EJAe∃ike]∃HXAi!JAMk9GiS←8AM←d↓oQSG AiQJ↓Kee←HA←GGUeeKH↓[Cr@↓←dA[¬r~∃]=hAQCYJAEK∃\Ak]QeCGK⊂\@A¬∃oCeJ∧~∀~∀@A∪h↓SfAa=ggSE1JAi↑↓GCYX↓ieCG∀AoSi A]↑A¬eOk[∃]if\@Qie¬GJRA∃mCYk¬iKfAQ↑@AB↓YSgh4∃←LA¬YXAi!JAMk9GiS←9fAGkIeK]i1rAEK%]NAiICGKH8~∀~∀@Ak]QeCGJ↓SfAkMKHAi<Ak]I<AiQJAKMM∃GifA=LAie¬GJAC9HAeKMi←eJ↓Mk]GQS←]fAi↑AQQKSd4∃]←e5CXXAU]ieC
KHAgQCiJ\A)QJ↓CeOk5K]hAQ↑Ak]QeCGJ↓M←dA∧AOSm∃\AMk9GiS←8@AgQ=kYHA J~∃o!ChAiICGJAIKike9KHAM=d@ASPvAR]∀\ASL↓ieCG∀@AeKQke]K⊂AM←↑0AkgJQk]iICGJ@↓M←↑RlASL~)ieCG∀AeKiUe]KHQM←↑↓oQKe∃S\AE¬dRAkMJ@Qk9ieCG∀@QM←<AoQKIKS\A CdRR8@@Ak9ieCG∀AoSY0~∃iC-JA[k1iSaY∀AgaK
SMSG¬iS←]LXAJ]≤\@Qk9ieCG∀AM←↑↓ckkpQECd↓oQKe∃S\@A CtRA→kaQ←<R\~∃
CYYS9NAk]QeCGJAoSi A]↑@↓CeOk5K]if↓oSYX↓k]ie¬GJ@A¬YXAMU]GiS=]f@A
keeK9iYrA KS]N4∃ieC
KH\~(~∀@@↓eK[iICGJXA←II1rAK]=kOPXAKqaU]OKfAiQJ↓K]iSIJ@AiICGJAACGWC≥J\@@↓∪h@AQCWKf↓]↑~∃¬eOk[∃]if\4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∃ ∃GK[E∃d@lXbrnn@@@@@@@@@@@@@@@@LfZb\T\f@@@@@@@@@@@@@@@@@@@@@AACOJ@LZfr~(_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀b\T\h@AQQJA'QKaaKH~∀~∀4∀@@AQQJ@A1∪' @EgiKAaS]NλAaCG-COJ@↓Sf@A%]iK]⊃KH@AQ↑AOSYJ@Ai!J@A→%' @AAe←Oe¬[[Kd↓B~∃M¬GSYSQrAC]¬Y←O←UfAi↑AiQJ↓∪]giIkGiS=\A'i∃`A[←⊃J@A←_Aek]9S]NA∧@A[C
QS]J↓YC]OUCOJ~)ae←OICZ\~(~∀@@@@@@@@@@@@@@@@@@@@@@@@@AQQJA%%GPA'QKaaKH~∀~∀@A)Q∀A%SG AgiKAaKdAACGWC≥J@AaI←mSI∃fABAMS[aY∀XAg[¬YXAI∃EkOO%]N@A
CaCE%YSir8@A∪h4∃SfA¬mCSY¬EYJA¬fABA1SEeCIrAae=OeCZ↓S\Ai!JA∪)LAS[a1K[K]QCiS←8\~∀~(α1⊃←\Ai↑AUgJAi!JA')∃ A
C
SYSid0α
∀4∀~∀@A)QJ↓aCGW¬OJAG=]iCS9fAio<AG←[ASYKH↓Mk]GQS←]f↓oQSG ACeJ↓YWCI∃HAEr4∀~∀@@@@@@@@@@@@@@@@@@@@Q→CgY←¬HAgi∃`AMCMXAIg,AYSE1g`R~(~∃)Q∀AkgKHAS]i∃eMCG∀ASfAQQe←k≥PAiQ∀AMk]
iS←\QMKqAdRAgQK`XA]QSGP↓gKifAgoSQGQKf↓i↑~∃AkhAi!JA→∪M AS]QKeae∃iKdA%\AC]⊂A←kh↓←L@EMiKaa%]NDA5←IJ\A)QJ↓ECgS AG←[5C]If↓CeJt4∀~∀~(@@@@@@@@@@@@!giK`↓hR@@@@@@w)ke8A←\AMiKaa%]NA[=IJ\~(@@@@@@@@@@@@!giK`↓]SXR@@@@w!ke8A←ML↓giKaAS]NA5←IJ\4∀~∃)!KgJA
←[[C9IfACIJAkgUCYYr↓isaK⊂AChAQ←`AY∃mKXX↓C]HA]SYXAQCWJ@↓KMMK
hAS[5KISCQKYr~(QR]J8AiQJ↓]Kqh↓&[KqAeKgg%←\AieaKH@↓S\Ao%YPAE∀AKmC1kCiK⊂AS\AMiKaa%]N@A5←IJR8AβYg<~∃-N0AS\A¬IISi%←\Ai<AeKiUe]S]≤Ai↑AQ←`AY∃mKXX↓ike]LA←ML↓giKaAS]NA5←IJ\4∀~∀@A∪\AMiKaa%]NA[=IJXAQQJA→%' @A∃mCYk¬i←dA]SYXAAeS]h↓←khA∃CGPAL[KqaIKggS=\@Ai<AEJ~)KmCYUCiKH↓EKM←IJ@AKYCYkCQS←\X↓C]HAQQJ@AIKike9KHAm¬YkJA¬MiKdAKmC1kCiS=\XAG¬YYS]≤~∃CiMKYLAIKGkeMSmKYdAi↑A⊃SgaY¬rAiQ∀AgiKAaKHA∃mCkY¬iS←\↓←LAK¬GPACIOk[K9hXAS_AiQJ↓&Z~∃∃qaeKMgS←\ASf@↓B@AMU]GiS=\@AG¬YX\@AβMi∃d@AI%gaYCeS]N@↓KCGPA&[KaaeKgMS←\XAiQJ4∃KmC1kCi←HAoSY0AoCSPAEKM=eJAKYCYkCQS←\A→←dAB↓G←[[¬]HAG!CeCGQKdAMI←ZAi!JAG←9g←YJh~∀~∀4∀@@@@yga¬GJ|@@@@@@@@@Aπ←]QS]kJ↓giKaAS]NAIKGkeMSmKYd\~∀~(@@@@yekE=kh|@@@@@@@@@↓'Q←n↓eKikI]KHAYCYkJ↓Me←Z↓iQSf↓YKmK0A←]YdX@AC9HAG←9iS]k∀~∀@@@@@@@@@@@@@@@@@@@Agi∃aaS]≤Akao¬eH\~(~∀~∀4∃!CO∀@fZh@@@@@@@@@@@@@@@@@@@@@@@&f4b\j\P@@@@@@@@@@@@@@@@↓ KGK5EKd@XX@br\n~∀_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@@@yGH|A←dyiCDx@@@@@A)kI\@A←→L@AgQKaaS9N@A[=IJ\@QEkh@AG←9iS]k∀@AKm¬YkCi%←\~∀@@@@@@@@@@@@@@@@@@@A]SiQ←UhAgi∃aaS]≤R\~∀4∀@@@A @@@@@@@@@@@@@@A%KI%gaYCdAGkeIK]hA→←eZA%\AMk1X@QR9J\@A]SiQ←UhAae%]YKm∃X~∀@@@@@@@@@@@@@@@@@@@A←HAaeS9YK]OQPR~∀4∀@@@A∧@@@@@@@@@@@@@@A∂Kh↓EeKC-a←S]PvAae=GKKH↓oSiPI ~∀4∀@@@A~@@@@@@@@@@@@@@A'KJ↓CImC9GKHA→KCikIKfAk9IKdAMiKaa%]NA≠¬Ge↑A∃qaC]MS←]f8~∀~∀∧1≠←e∀AβIm¬]GKH↓
KCiUeKf0∧~∀~∀4∀@@AMKYKGQSmKYdAike9S]NA=\Agi∃`t~∀4∀@@@@@@@@@@@@@@@@@@@@@@@@Qgi∃`AM←<bAM←<d@\\8R~∀~)∪LAi!SfAG=[[C]⊂ASfAQsaKHAChAQ←`AY∃mKXX↓giKaAS]NA]SYXA9←h@A
←[[K9GJAS5[KIS¬iKYr0~∃EkPAeCi!KdAo!K\Ai!JAKm¬YkCi=d@AM%eghA∃]G←k9iKef↓BA&[∃qaeKMgS←\↓oQ←g∀AGCdASfA=]J~∃=L@AM=↑bXA→←↑dXAKiF8@@A)!SfAM=eZ@A]SYXAQQK\@↓ISga1Cr@A¬hAiQ∀@AG←9g←YJ0@AC]⊂AiQJ4∃KmC1kCi←HAoSY0AEJA%\Agi∃aaS]≤A[←I∀AoCSQS]NA→←dAB↓G←[[¬]HAG!CeCGQKd\~(~∀@@↓'iKaAS]NA5CGe↑↓ qaC9gS←]Lt~∀~(@@A∪_AiQJ↓giKaAKdASLAae←
KKIK⊂AoSi AB@yMaCGJxXASh↓oSYX↓]←hAMiK`AQQJAKaKGki%←\A←_~∃[C
e↑AKaaC]g%←]fX↓EkhA]SYXAICiQKHAUkgPAgQ←\AiQJ↓eKgk1hA←L↓iQJA5CGe↑↓←LAKaaC]g%←\~∃¬]HAo¬ShAM=dAC]=iQKd↓G←[[¬]H\~(~∀@@↓)↑Ag∃JAiQ∀AKqK
kiS←8A←LAQQJA[¬Ge↑A∃qaC]MS←\A%igKY_XAae=GKKH↓iQJ@↓giKaAKdAo%iP~∃¬\A~A%]giK¬HA←L↓B@ygACGJ|8~∀~∀@A+g%]NAgQK`Ao%iPAEIKCWa=S]ifh~∀~∀@A)Q∀ACE←YJAIKMGeSaQS←\A¬aaYS∃fAi↑↓ike]%]NAgQKaaS9NA←\↓C]HA=MLAO1←ECY1r@ACPAi←`4∃YKm∃X\@A5←eJA⊃KiCS0ASfA9KGKgMCerAQ↑Akg∀AgiK@AMYKaSEYr↓S\AC9HA←kP@A←L↓EeKC-a←S]Qf~∀Q∀]N\AQ←OKi!KdAo%iPAiICGJR8~∀
∀@A∪L↓giKaAS]NA%fAikI]KHA=\AErQgiK@AhRA¬hAi←@AYKm∃XXAi!JAKm¬YkCi=dAoS1X@A≥=(AEJ4∃S\@↓giKaAS]N@↓[←IJAoSi!S\@A∧@AEe∃CWa←%]hAY=←`\@A∪L@↓s←j@↓oSgPAi↑@↓kgJAMiKaa∃H~∃KYCYkCQS←\@↓oSiQ%\@AB↓EeKC,@AY←=`@As=jA[kMh@AiUe\@A%hA←\AY←G¬YYb@↓Er@@!giK`↓hR\~)π←]m∃agKYdXASL↓giKaAS]NA]Cf@A9←hAiUe]KH↓←\ACPAi←`AYKm∃XAC]⊂AShA%bAikI]KH@↓←\AEd~∀QgQK`Ah$AS\A∧AEeK¬VAY←=`XASPAoSY0@A≥∨PAEJA=\AoQ∃\AeKQkeLA%bA[C⊃JAMe=Z@Ai!JAEe∃CV~∃1←←`A r@I 8~∀
∃⊃KGK[ Kd@l0@brn\@@@@@@@@@@@@@@@@&fZb8j\h@@@@@@@@@@@@@@@@@@@@@↓!COJfZhb4∀ **DRAFT** Maclisp Reference Manual **DRAFT
*
Hkwever, executing (step nil) inside a break loop will turn off stepping
globally, i.e. within the break loop, and after return has be made by $P.
The most useful feature iS the following, however:
(step) Command at top level has no immediate effect.
After (step) has been executed at top lEvel, a subsequEnt (step t) inside of
A break loop will have the effect od turning on stepping mode both inside the
break loop and globally, i.e. the evaluator will start to step as soon as the
retqrn is made from the break loop by $P. Thus, for instance, one could set
trace to break at some special place, and then use the break to turn on
stepping.
prinlevel and prinlength:
In the present version, for convenience, prinlevel and prinlength are lambda-
bound inside the hooking function to 3 and 5 respectively. These could be
changed by editing the expr code and recompiling.
When the P command is used, prinlevel and prinlength are temporarily bound to
nil, and the toplevel printer (the value of atom prin1) is used to redisplay the
current form.
Overhead of Stepping:
If stepping mode has been turned off by ↑g, the execution overhead of having
the stepping packing in your LISP is exactly nil.
If stepping mode has been turned off by (step nil, every call to eval incurs
a small overhead--several machine instructions, corresponding to the compiled
code for a simple cond and one function pushdown.
From an overhead point of view, running with (step) entered at top level is
the same as running with (step nil).
Stopping stepping by responding <tab> incurs the same continued overhead as
(step nil).
RuNning with (step foo1 foo2 ...) can be more expensive, since a member of
the car od the current form into the list (foo1 foo2 ...) is required at each
call to eval.
Page 3-42 ∪3-1.5.4 December 6, 1977
**DRAFT** The System **DRAFT**
In terms of memory requirements, the total compiled stepping package occupies
about 423 words of binary program storage.
Interaction with debug and trace:
No special interactions of the step package with debug, trace, or any other
system packages are known.
The Morgenstern Stepper
The Morgenstern Stepper package provides debugging capabilities for
interpreted LISP programs that are comparable to the capabilities provided by
DDT for assembler code. These capabilities include:
1) Single stepping through the evaluation of a function and over or into other
interpreted functions, when called, on a selective basis as determined by
the user. Each such form and its resulting value may be displayed.
2) Dynamic breakpointing on one or more of the following conditions: the form
or atom about to be evaluated matches a pattern you provide; the form being
evaluated involves a specified function; a given atomic symbol evaluates to
a given value; a given atomic symbol is to be bound in a prog, either type
of do, or an eval'd lambda-expression; or upon an arbitrary condition
specified by a predicate written as LISP code.
3) Returning a different value for a given S-expression. This allows for
changing the action that would be selected by conditionals in the program
and/or by go's in a prog or do. You can also go to any tag inside the
current prog.
4) These capabilities may be requested when the program is initially started by
a top-level form, or they may be initiated at any other point in the course
of execution - either from the terminal while in a breakpoint, or directly
by the program.
The stepper may be invoked initially by using the function mev as one would
use eval of one argument; e.g. (mev '(fcn arg1 arg2)). From a breakpoint op in
a program, the stepper may be turned on by invoking (hkstart) with no argumefts.
It may be turned off by the q command described below, or of coursE by a CTRL/g
December 6, 1977 ∪3-1.5.4 Page 3-43
**DRAFT** Maclisp Reference Eanual **DRAFT(T~∀~(~∃Ee∃CVL@↓βEiKHA[Kl↓KmCYUCiKf↓SifA¬eOk[∃]hXA%hAeKQke@;~βS#∃π3π3W*βπ;⊃¬#WK≠~β?≠→π##∀4Tε7&/∞ W∩r∧ f␈&T∞FF∂D ⊗rα∞Mε*ε≤-w6* X∞ ≥<≠⊂∩H:42P→4πrm given ac an areume@9h@Ai<A[Kl4∃`∨π~βGW∨&+⊃9↓∧K⊃1β≡ e "∞Mε*πl≥G.(≠qD H≥x.∀≥~→$
hεr`8pression (dcn arg1 arg2 , then
∃←9JAG←UYHAkMJ@@#n+Yβ→Jβ';O&+π"aQ hR∧∧∧∂"∧λ⊗wJ∧
ε}NnDε'∂-→f*α∞Mε*α∞8
↑≤~3LUλ≠p↔→P⊂6p↑P⊂4g≤βpec@PAaQJAeCYUKf@A=H β?&C↔H∀Tεf∂⊗α88ML<kλ ≥Yλλ ↑Y;@⊂≤αea`Ply mev to a`≥r↓IP∨Khq↓↓α&C'Mβn eβ *↓β∪?v)β'→αβ↔'SF+Aβ?0h#@&∞,V*π|∨↔
R∧λV∞≡∧λλm⎇98;LD≥z3
D_Y(∞∞Y{<∞L9λ⊂∪≠y⊂1<H↔SV⊂≥yzpv≠<P3 /lh ←o%]NAi!JAYCMh∩+4{@⊗J∞
&NwLXBε←↑Abα∧≥o∩¬~\X∞∞∞Y<tm≥{H⊂~~0z⊂⊂~yP:<\2r⊂ 7hich↓SfA]=hAeKα≠?∨;Lπ&.α∧λ↔4_#"L={;8-lλ≥z-Mα⊂12H2{0v p⊂∀;Zz44`. af @∃` KO,εBπ&tλλl≡_z⊂→y97`2pεR\@↓βYiKI]CiSYKYbX↓iQJA∀~∃G←5[CMHαβS : X
L≥λ_;O∀λ→0≤≤92y`3ion, or the h Comeand to get a ni@
JAisββ∃↓β|∧b∧≥J)B`=β"P⊃≤2puGλ⊂⊂"4~yP4iH92pv≠<P0@ APRL/b break$ But i@PAkgK⊂Ai↑A JAπ)I_←PAM↑@Ai!JAG←5[CMH4∃QCAAK]fAQ↑AEJ↓GCYY∃HAP\$~∀
∀@AS\↓iQJA%if@A%[aYK5K]iCQS←\A∃CGPA
←[[C9HA[kMh@AE∀AM←Y1←oKH↓ErABAgaC
J@Qk9YKgf4∃iQJ↓G←[[¬]H@A%bAB@↓YSgh$\@AS8AiQJA[kYQSGfA%[aYK5K]iCQS←\@↓KCGP↓G←[[¬]H@A5kghA J~∃M=YY←o∃HAEr↓BA]K]YS]J8@ACGQkCYYdXAiQ%fAIKnmode). each form and result which is printed out will be followed by
#number indicating the relative level of evaluation (i.e. stack depth since
invocation).
the primary commands are:
d (mnemonic for down) go down to the next deeper level of evaluation and
display the first form there before evaluating it. e.g. if the form is a
function call, this will display the first argument of the function if it has
arguments in the call; otherwise it will display the first s-expression of
the body of the function. it then prompts for the next command.
e (eval) can be used to evaluate an arbitrary expression. it starts a new
line, waits for you to type the expression, then eval's it within an errset,
and prints the result. this is comparable to just typing the expression or
atom after the //, but cannot be confused with a command, and the format is
nicer.
h (control-h) enters a break loop, and when $p'ed displays the current form.
within the break, one can inspect the values of variables, etc., and even
reapply mev to any form.
n (next) Display the next form at this level, without showing or inspecting the
evaluation of the lower levels of the current form. The value of the current
form is displayed first. If you wish a condition to be tested for at lower
levels, use nn instead.
Page 3-44 ∪3-1.5.4 December 6, 1977
**DRAFT** The System **DRAFT**
nn Like n but slower since it inspects the lower levels. Use instead of n when
testing for a condition.
u (up) Go up to the next higher level of evaluation and show the next form at
that level. The form(s) at the current and lower levels are evaluated
without display. As an example of its use, after you have seen the
evaluation of the arguments to a function, the next form to be evaluated, if
the function is being interpreted, will be the first S-expression of the
function; to avoid seeing how the function is evaluated internally, you can
type u. Note that the lower levels are not inspected - thus if a condition
is to be tested for at these levels, use uu.
(u num) If num is positive (or zero), forms are not inspected nor displayed
until level num is returned to. If negative, it goes up (abs num) levels
relative to the current level. Thus (u -1) is equivalent to u.
uu Like u but slower. Use if testing for a condition.
(uu num) Like (u num) but slower. Use if testing for a condition.
q (quit) Exit from the stepper.
s (show or display mode) For datapoints and other display teriinals, this
gives a niCe easidy read output od∧@Ag∃YKGi∃HAYKYKYf@↓iQChα↓β∂?w≠S'S,εF*πM PhR∧∧ε≡}nLWGλλ≠l@⊂:42H⊂1zi≤2w:⊂→{0v:Xz4ww ⊂⊂⊂)\2qts~qpv&≡T∧ iT seLects the current
level fOp sp@IS]hO%]N@QAeKiIdAaeS9iSMNαI↓βπ~β¬↓ F+π&↑ "bε≥lBε∂4 ⊗␈*∧ vzεLXWε/%APBα∧λ
(≠⊂↔Xpp @
←]iKah@ASLACEEIKm@'∂#∃'C⊗K;@&\@λ∞]Y→0→λ⊂:44\P42`!der, and the CurreNt ∀@AWkiAkhAo%YP⊃β⊗)βOC⊗K;A∨,!1↓β~β7πe∧∧&*π↑8 ,D_8h
|]→3D <h⊗-}(≠⊂∀Zβa. Headers @]SYX~(@@ACUiW[CQSGCY1r@AE∀Aa←AAK@@Aβ;#↔→¬K?U↓¬∪↔SW⊗q0∩α
Mε*α 8 m]8;Y∧¬≤hλ
n9*(∧∞y;⊂∩Xz9P CE⊂⊂⊂≤0y0∀icudar le@YKX@A¬`
β¬αβ#↔π&+I9↓αα'Qβ∞s⊃↓β&C∃↓β≤¬vnn≥lBπ≡d∧ε∞vD∧π<α{2`2al u@MKd4R↓↓βO,εG&∞-H $∞_8X-\αz2`2pεAC@⊗)β∪↔≤≠@⊗N,XBεNβH⊂~~2P6w\αe deta`∪Yα+⊃βO,∧7&Nβ{@⊂_2r7`7,∧⊂∀!Q"C@(≤k,←≤
(∧∧∃~→$
hεr`8pres@MS←\@↓SfAgβ+ OSLεG/&\@λ∧ Xπq the cur`%∃]`⊃β4¬w-αP⊂ !nd anothe@H~∀@@↓G←[[¬]HASβ→βCK|¬Wπ→9⊂→αh∂d@!RP≠∃p∧πN␈Tλλl≥Hλ⊂→]2x⊂ )npo @=` β?αh .⊂:42H52{@ d¬P∨Kh∧αεNd ⊗␈(Q$ααπ|≥g"πMu∩`$λ⊃z ]H≥~ T≤Y4n]≥~3LT≥X;∞\αP4`3 retupjed↓ShAo%YP⊃β⊗)βπM∧¬⊗ $≥~→$
|Z0∪Zw0vεB⊂⊂⊂ &ore Ha`λAsαK↔3∪,!βC#∂!βKπe+∃ 2∧λf␈∩ X∞ ≥<≠⊂∩K⊂8wjH1pw change the ap@ACeK]PAaeKβ# ($∧αε←$λ L≥≤z0~≡P7s⊂≤92r4Xpz2yH⊂7q_<x0y\P0P∀→wP⊂&_q2v∀K⊂0yP≥p¬dl as Just @IKike9S]N~(@@AI%H ≠↔⊗+;Aβ4 3@.↑4ε6@|H⊂⊂[⊂)Vr↑892i\tp∂n∞
~∀!G←]HX 99J↓αS↔∨#@~α iwαε=x LM=~;mnh≤∀M≥|H∃
tλ→=L≥≥8=
≥{H≠l@⊂2pqZ⊂3:j≥y2P⊂→5y6Fλ0s2εB⊂⊂⊂;Z2w⊂9Xz4ys~rr⊂+Zv6⊂8≤4w:⊂_P⊂6r\ypsrK⊂24y\60tP≥42P3≠y2V⊂_w2⊂;Xtz⊂⊂→5y⊂0[7z42\εA⊂⊂λ1wvvXw2⊂∀≥t4qtλ6p|P≠s⊂1g]y9rP_2P4→5y⊂ H192pZTW⊂⊂∃42P0\3zvr[:⊂:7H:44yH1ww2λ4yFEβEαE"→qrvq→y⊂≠⊗λ_\[[H⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXW
W~⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∀0srP VZ~FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP&pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂_w⊂⊂0\14z9_y<P)Kr|89→yytw[⊂⊂7yλ9|vq≠v⊂⊂;Z4qt⊂~yP⊂2]0v:p]2r⊂6~urP⊂_P892Y4qpz→WεE⊂λ⊂*44\P4yP≤tvtv_y⊂:7H:42P_ww2⊂→2pz:\2P7sλ:42P≥90qrH80quXsrWεBεE⊂⊂λ$w⊂9\2qts≡tw3P≥42P8≤2r4qXz2V⊂≥42P⊂→7y6P_q7zzλ:7P1→P2{0[:pz2Y⊂6p|H⊂12P≠q:0t[2rεEλ⊂⊂0yH:42P≥0v:rH7s⊂:~2P;0\4pq6→P∩Rs≠y6W⊂λ*42P→|892\ytwwλ∀47wZv2{2[∀P⊂9→z:y7≤P:42CE⊂⊂⊂≤2v0z~{2P6→{2v⊂≠s⊂2{_v:pz~ww↔⊂λ&wy2H:40wλ7w2P≤92r4Xpz2P≠p|P1→P3t{→w⊗⊂4[⊂;t4XtεE⊂λ⊂1pyYP:42↑P0y2H7y∪rY⊂:7sYz42y ⊂⊂2|_rx:⊂≥t2w⊂≥;wP0\3zvr[:9P3≠y6P0H⊂9x2Xtpv⊂≥2yzεB⊂⊂⊂0\P22yXy4q2Y⊂4w⊂≥42P6[y2P⊂→2z0t[2r⊂9Yqz4w[⊂12v≠{W⊂⊂∃42P1[w24z~ww⊂⊂≥tv6⊂≤2vpt[εE⊂⊂λ0qz4]2P⊂0]⊂0v6λ⊂62{→v9P:~0z⊂⊂_y2P4[9x2q]2r⊂⊂_<P:4→P⊂9z→x82yλ⊂:w:~v⊂2|≤64qt]6<FEλ⊂⊂::\72r⊂≠s3⊂1≡P∀1w[2⊂74[∀WεEβE⊂⊂⊂
6pz1Z3⊂↔↔ ∀P4yH0P3:[1z4w[⊂;t4Xt⊂;t[6⊂80]:2y7λ6pz1Z⊂0spZw9z⊂≥42P1]y92w≥⊂37y≠WεE⊂λ⊂$z⊂≠p|P1→P:yrY⊂4w⊂≥42P8≤2r4qXz2P7Y⊂:42H1ww2 ⊂⊂∀ [9wP9YrP4z≤P92v_z2r⊂≥yrP⊂_yP0FB⊂⊂⊂1[vvpw→↔∀P⊂∃42P0\3zvr[:⊂⊂:≠P6pz_t3⊂4\P1wv\0y2rλ⊂:7P Rs7y≠P2v2[rw:⊂λ1<P2[2vrw≥εE⊂⊂λ397vH62s:λ:7P9~st:⊗λ0w2⊂λ9zqqYrr9P≥t2w⊂→pqt⊂→v2vr[:⊂7sλ:42Pλ80z:→y7⊂9]qqrrY9WεEλ⊂⊂'sλ⊂4vx≠y:0w_rV⊂:~2P⊂8_sively to sublists, unless the
sublist is of the form (# ...) in which case # is bound to the current
element of %%form and the cdr (not cadr) of the #-list is evaluated as the
test on that element. Except in this case, atoms and lists should be given
as in the original code since they are not evaluated. Some simple examples
are:
(matchf xyz) succeeds if the atom xyz is about to be evaluated.
(matchf (setq alpha)) succeeds if the atom alpha is about to be setq'd.
(matchf (putprop name * 'source)) succeeds if the property source is
about to be putprop'd on the atom pointed to by (i.e. the value of)
name.
(matchf (setq (# member # '(alpha beta s3)))) succeeds if either alpha,
beta, or s3 is about to be setq'd.
(matchf (rplacd * '(* 9))) matches (rplacd (last urlist) '(2 9 4)).
(matchf ((# member # '(foo bar)))) succeeds if a function call to either
foo or bar is about to be evaluated (more precisely if the car of the
form about to be evaluated is either foo or bar).
nil (cond nil) turns the condition off and saves the current non-nil condition.
Page 3-46 ∪3-1.5.4 December 6, 1977
**DRAFT** The System **DRAFT
*
(cond) When no argument is given, the last non-nil Condition (which is the old
property of %%cond) is established as the current condition (whiCh is the
value of %%cond). (Id∧AiQ∀AaeKYS←kf↓G←]I%iS←\↓oCfA9←hA]%XAiQ∃\ASh↓SfAg¬mKHA¬f~∀@AiQJ↓←YHAAe←aKIirXAQQkfA¬YY←o%]NAM=`ACYQKe]CQS←\A=H βS>yβ∂?v#'S'}sM9$hP4)#n S∂#2↓999Jβ'Mβ/ W'[∞c↔;Q¬#=↓β≤{;⊃↓FkπS∂F1↓99rI%1β≡+∃βπ⊗{[∃8hP4(∧E##∃β4{33?>K;≥β7+;∂SN{;Mβ∂∪∃βW≡+∪G1∧¬⊗rε=x Ml8⎇~-⎇H≥z.Mλ≥~ T≤⎇→.∞→<F∃A"C!$λλ
|⎇_..λ(⊂≠Zv6⊂4[4z4p]2P9z→x84g→P;t2[⊂2w1[zw:2\2r⊂$[⊂0P 0rogbam or tq`Ed from
αabreakpoint,∧@@Q!Sgi←@RAoS1XACGPAYSW∀AiQJ↓bAG←5[CMHαβS :∞NWεr
xf $λ≤u ↑≤~3LuH
⊂-N{c"N<αrP!→v7{P→4πr More Info.$~∀4R↓↓↓βn∪π-∀λ
.P⊂0@→8s1`4ion To be qse@⊂AYSW∀@AiQ∀A→∪'@AgcGβ#↔5∨~↓↓# ∞[3'O I0∩α¬
V⊗∞5⊃PW∨N-↔π~
}W"εn-vjπM Rπ⊗↑8
-Nα⊂7`& (baklist$AaQ←β≠∃β≠,s∂S'|s@~πM ↔"ε ≡f*πMtε&Z∞⎇↔&B∞Mε(hα\p~→x82`2,∧∩(hQ↓↓α&C∃βK,kπ'lLW$λ≠qD∞~~0→H9rq`4ion is a↓G←[a1KiJ@↓YSghαβ?2∞Mε*αλ8
↑≤→0→λ1wvvXw29VβE;t4Xt⊂1`!n be used↓H ?$λ L\β2y2[1rWεB∧@
Commandc whicH are nkt @1Sgif↓[kgh↓EJAMα{3#?>+⊃β Jβ¬βO∧∧⊗≡
d∧¬N␈Tλλl≥H≥<lT≤Y0⊃≠zzεE_2s7`2e co@5aP∪↔&K;≥β&C∃β∂|¬Vn∞l@λ¬ 8π2 its Space i` A]∃G@↔O≤∧↔/*+@⊂λ⊂ v 4er`≥CQSmKYβI1β@≥zPhVβ8>$ 8[p→≥⊂:42H1wvvXw2⊂ "ebg`%∀AG←[AYKiSαs⊂~ε≤@ε↔J MvNvtλλ$λu∀S¬@|⊂19→pqWεB∧@
Afy S)express@%←\Ai!ChAs=jAiSAJAoQ%GP@A%`
β;⎇!βK↔≤{↔;πT∧V"ε≡4ε
ε=x -\9Y⊂λ;tv , be
evaluatedQgSi!S\AC8AKeeMKhAi<AGCI
PAKeI←efR8@A)QUbA`'␈)β∂πpβ↔[πg+πS∃ε ;eβ∂#?5β|ε hVMtε∞w∀ g.v>M⊗}r 8λ-Mλ≤z-↑≠≡( /(λ≥∂≡~;Yd
=λ⊂∪≠v67{Zw3P:~2P89≠vx:4[3P↔WH0yP⊂≠5w3P_yFE )t is not @%]iKeAeKiC YJ@A¬fA←]∀A←LAQQJAG=[[C]⊃f@AE∃Y←n@!←dA]%XR\@↓≥WiJAiQCPAs←J4∃GC\↓CGik¬YYbA≥↑Ai↑ABAi¬NAoSQQS\Ae←kdAAe←N@↓gS[a1rAEr↓isaS9N@QO<AiCN$@ACMQKdAi!J~∀↑<\@A)<AKmC1kCiJ↓BAM←IZAoQ%GP@A1←←Wf↓YSWJ↓BAG←5[C]H0Aisa∀@Q←d↓MWeZ$@Ai↑↓KmCYUCiJ~)ShXA∀]N\@!←dAB$AKmC1kCiKLAiQJ↓Ci←Z↓B\@A%LAs←TAoC]PAs←j↓GC\A∃mK\@↓oeSi∀AMk]
iS←]L~∃oQ%GPAW9←nAC ←khAQQJAgQKaaKHAC]H↓ieKCPAiQK4ACfA
←[[C9If\~(~∃B@@@QC1XRAβUi←[CQSGCY1r@AI%gaYCefACY0AM←e5fAC]⊂@AmC1kKfAMKK\A rAiQ∀@Agi∃aaKd↓Ch~∀@@@A¬YXAY∃mKYf8@A)sAS]NA∧AgaC
J@ACPAC]r↓iS[J↓iQKe∃CMiKHAoSY0AGCkMJ@Ai!JAgi∃aaKd4∀@@@Ai↑A1KCmJ↓iQSf↓[←IJ↓C]HAAe←[aP@AM←HABA]∃nAG←5[C]H8@A∪L↓s←jA]C]h@↓iQJAMiKaa∃d~∀@@@Ai<AoCSPAM←d↓BAG←5[C]H↓CMiKHAKCG AM←e4XAs←TAGC\↓kgJAQQJAH↓G←[[¬]H\~(~∀@@@Aπ←5[C]ILAB@A¬H@QBZR@A AC]H↓GF@AACkgJ↓CMiKHAKCG @A]K\AM←e4ASf@↓ISga1CsKH↓SL~∀@@@@∀KCF[MYKK`↓SfA]=\[]S0\@A∪QfAmC1kJASLAkgK⊂ACfAQQJAg1KK`AQS[JA%\AgK
←]If8~∀~∃¬H@@@!CYXA⊃←o\R↓βki←5CiSG¬YYrA⊃SgaY¬sf@A¬YXAM=e[fA¬]HAm¬YkKf↓K]G←U]iKe∃H@AEdAiQJ4∀~∀~) KGK5EKd@XX@br\n@@@@@@@@@@@@@@@@&fZD\j\h@@@@@@@@@@@@@@@@@@@@A!CO∀@fZh\~∀_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@@Agi∃aaKd↓S\AKYCYkCQS]NAQQJAGUeeK]P@AM←IZ@QR9J\ACPAIKKAKdAY∃mKYf$\@@AQsaS]≤AB~∀@@@AMaCGJ↓aeS←H@Ai↑↓G←[a1KiS←8AoSY0@AGCUgJAi!JAgi∃aaKdAi↑A1KCmJ↓iQSfA[←I∀AC]H4∀@@@Aae←5ah@A→←dABA]Kn↓G←[[¬]H\@@QβYM↑@Ag∃JAH\$@@A'1KKaf↓CMiKH@AKC
P@AM=eZXA¬f~∀@@@AI∃gGeS KHAk9IKdAQQJAB↓G←[[¬]H\~(~∀QB↓YKlRAβki=[CiS
CYYr↓ISga1CsfA¬YXAM=e[fA¬]HAm¬YkKf↓ChAi!JAS]⊃SGCi∃H@AY∃mKXA¬]H~∀@@@A1←oKdQIKKAKdRA1KmKYLXAikI]S]N↓SigK1L@A←→LAoQ∃\AKm¬YkCi%←\Aa=afAi<@ABA1KmKX4∀@@@AoSi AB@AM[CYY∃dAYKYKX@A9k[EKH\@@AQsaS]≤@ABAMaCGJAaeS=dAi↑AG←[AYKiS=\AoS1X~∀@@@AG¬kgJAQQJAgQKaaKHAi↑A1KCmJ↓iQSfA[←I∀AC]H↓ae←[AhAM←HABA]∃n@AG=[[C]⊂\@@Q¬Yg↑~(@@@@↓gKJA⊂\R@AMYKKaLACMi∃dAKC
PAM←IZXACLAIKg
eSEK⊂Ak]I∃dAiQ∀ABAG=[[C]⊂\~∀~)D@@@↓'Kif↓BAEe∃CWa←%]h@AQ↑A←G
kdAC→iKdA∃mCYk¬iS←\A←LAQQJAGUeeK]PAM←e4\@@A¬hAiQ∀~∀@@@AEe∃CVXAQQJAm¬YkJAQ↑AEJ↓eKikI]KHA%fAiQ∀AmCYUJA←LJKmC1kJXA¬]HA[¬rAEJ↓GQC]≥KH~∀@@@A rAgKQbOS]≤AiQSLAmCe%CEYJ8@A)Q∀@AM←IZAiQ¬hAsS∃YIKH↓iQSf↓mCYk∀ASf@↓iQJAYCYkJ4∀@@@A←L@∀KM←e4\@A)eaJ@I@Ai↑AAe←GK∃HAMe=ZAiQ∀AEeK¬Wa←S9h\@A%LAs←TAaeK→KdAi!ChAi!J~∀@@@AgegiKZ↓oCSh↓eCiQ∃dAiQ¬\AEe∃CVAg∃JAiQ∀AoiS_AG←[5C]H\@QDA=aKeCQKf@A rACI⊃S]N~(@@@@↓iQJA
keeK9hAQ←=WYKm∃XAi↑@JKEIKCWY%gh\RA3←j↓GC\A≥KhACUi←[CQSF@A eKCW%]NACP~∀@@@ACY0AYKm∃YfAEdAkgS9N@Qe∃iG←]⊂AhRA=dAG←9ISiS=]CXA eKCW%]NACL@AIKMGeSE∃HAEK1←n~∀@@@A→←dAi!J@Qe∃iG←]⊂@\\\$AG←[5C]H\4∀~∃F@@@Q
keeK9hRAβUi←[CQSGCY1rAISMaYCsLACYXAM←e5fAC]⊂AmCYUKfACPAUkgP@AiQ∀AGkeIK]h~(@@@@↓YKmK0\@@AQsaS]≤AB@AMaCGJ↓Ch@A¬]r@AQS[JA⊃keS]≤@AiQ∀AISgAYCr@↓oSYXAGCkMJAiQ∀~∀@@@Agi∃aaKd↓i↑AY∃CmJAQQSfA5←IJA¬]HAaI←[ah↓M←dA∧A]Kn↓G←[[¬]H\@↓)QJ@↓giKaAKdAI=Kf~∀@@@A9←hAS9gaKGPAiQJ↓MWe[LA←LA1←oKd↓YKmK1f@ZAQQkfA%LABA
←]ISQS←\A%bAi↑↓EJAi∃giKH4∀@@@AM←d↓ChAi!KgJA1KmKYLXAkg∀@AGF8@@A'1KKaf↓CMiKHAKCG AM←e4XACfAIKg
eSEK⊂Ak]I∃d~∀@@@Ai!JABA
←[[C9H\~∀4∃GF@A→SW∀AFXA khAS9gaKGQfAiQ∀AY←o∃dAYKYKYf\4∀~∃GQ←N@A→YSaf↓iQJ@∀KG←]⊃]←iC1Y←nAQ←OOY∀AoQS
PASf↓S]Si%CYYr↓hXA[∃C]S]≤AI↑A9←hAC1YWn~(@@@@↓FXAZ0A\XA=`AjA
←[[C9IfAS_ABAG=]ISi%←\ASLAEKS9NAiKMiKHA→←d\@↓]SXA5KC]f↓CYY←\~∀@@@AiQ∃gBAC9soCr8~∀
∀!G←]HX\\RA)KgQbAM←HAG←]⊃SiS←9f@AaIS←dAQ↑AKm¬YkCi%←\A←_AKCG AMkiUeJ@A→←eZ\A
←D4∀@@@AaCiQKe\A5CiGQ%]NAC≥CSMgPAiQJ↓MP∨Kj↓βWOLs∃βSF)β7π&≠#→β4εVv∨M≥vrε≥lBαεmx D
⎇~→.!"Hλ∧∧λ~;LM|[8.M;{@∞≤9(≥
(→→.<|Z<∞M;{H
|H
_m⎇Yλ EeJ(⊂,-⎇Y+AQ@εE)\2qtp[⊂:2y]9P3'\⊂⊂1`/nd ...) 44⊂@@@A)↑@↓CSH@↓iQJ@↓caKG%H '∂∂#'?9αβ?→β≤{77?r↓βC↔∨#E!↓π##∃↓ε3?33␈;';≥α↓β≠3∞;E β∂∪∀4)α↓↓↓β¬∪?['redicate given to cond. If the first argument to the cond is from the
set (form formq bind bindq atomval atomvalq fcn fcnq and andq) then the
Page 3-48 ∪3-1.5.4 December 6, 1977
**DRAFT** The System "*DRAFT(T~∀~(~∀@@@AgK
←]HA¬eOk[∃]hASL@Akg∃HAi↑↓IKeSYJAB@↓iKgh8@A)Q%fAae=GKgf↓Sf@AIKaKCQKHAo%iP~∀@@@AQQJAe∃[CS]%]NACIOk[K9ifX@↓SLAC9r\@AQQJ@AIKgkYQS]NAQKgif0Ai←O∃iQKdAoSi AC]r4∀@@@AeK[¬S]S]≤@ACe≥k[K]QfA]←P@AgCQSgMs%]N@AQQSfAAe←GKMfX@A¬eJ@A∃MMKGQSmKYdA←dO∃H~∀@@@Ai=OCiQ∃dAi↑AIKe%mJAi!J@A←YKeCY0AG←]⊃SiS←8@@QKaGKah↓M←d@↓iQJA¬]H@A¬]IbA→YCN~(@@@@↓gaKG%CX@AQKgif↓oQSG @ACe∀AC]H≥KHR\@A)Q∀ACeOU[KMiL@ACe∀A]←hAKmC1kCiK⊂AoQK8~∀@@@AisAKHAEUh@ACIJAKm¬YkCi∃HAKC
P@Ai%[BAi!JAG←9ISiS=\@ASLAiKgQKH\@A)QKMJAMY¬Of~∀@@@A∃CGPA5CrAE∀AkgK⊂A[←e∀AiQC8A←]G∀X∩∀~))QJA5KC]Sαs∨Mβ|1βS#-≠∃β≠f ∨Mβ∂∪∃h4Ph(4)α↓βπ≠' ↓↓↓α↓↓↓↓α↓↓↓α&C∃β;-CQ↓β∂∪∨W7,sQβ'~βπ;⊃>+⊃↓β>KS!β&C∃βK.kπ'≠Ls≥↓β&+OSMbβπ;⊂hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αβ7WO"↓βg'.c⊃↓β
↓β;?rk;'1αβ[π3.)↓β≠⎇⊃↓βSF)↓βK.kπ'≠&+I↓β}1↓βSF(4)↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓β∂|s∪'SN{9βSz↓βOW≤≠↔↔⊃r↓↓"O,)↓βSF)β∂?nk↔;S~↓β≠?∩β∂?;"↓β'9π##∀4R↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α∪∂?7εc↔S∃εc'OQε{→β∂|k7π;'→ β .c?]β⊗+∨πK&K;≥β&C∃βW≡)↓β?2βO'∪(h)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓β↔≠6+∂SMHh(4)α↓βπS}k[π3
↓↓↓↓α↓↓↓α&C∃↓βv+cQβ∂∪∨W7,sQ↓β≡C?W3"β ∃↓ε β3'∨!↓β?2βS←=αβ↔3↔n+;SMbβS#∀hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αβ≠'K≥!↓βπr↓#W;∂+?S↔ I↓β;∞k∃β?2↓βπ9ε S?5b↓βπ;"βS#∃αβO↔∂}s⊃βSF(4)↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓β[∞cW∃β}1βS#O→βπS}iβ≠?∩βS#∃π#↔OQπ#=βO.≠∂↔↔"p4(4R↓↓β Ns∪E↓α↓↓↓↓α↓↓↓↓¬;πS∂Bβ≠?Iπ##∃β4{33?>K;≥↓G+;GW⎇#↔⊃%ε S?7N→βOgn∪?1β&yβ ∃ε∪?W; h)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓β'9αβ¬↓βπ∪?≥1ε{I↓βNq↓β↔O##↔IαβSgC*β?→↓ε#=1↓ε{I↓β∞qβ↔cεc'∂'&cd4)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓β/3π3W∂#↔⊃↓εcπ7 & ↓#π~↓β∪'∨#';∂"↓β≠K}iβπ9αβπCCfK↔⊃↓εcπ7 & β?HhQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αβ≠W;∨#'?9ε≠π31Jp4(4R↓↓β≠≡sE↓α> S∂!ε3?Iβ&C∃β≠}c3?←Ns≥↓#.sGW?&+⊃%β7+;∂SN{9β;∞k∃βSzβ ∃β≡+↔9β↔I↓β↔6 1βπ_h)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓βS#*β∂πIαβ?→β&C∃↓β6{K5β∞∪?WQπ#=↓β⊗)β↔[∞cWπS.!9↓↓αBS#'~β∂π;v{P4)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓β≡C↔∂-ε3?Iβ∂βC3'.!β?IεkπCC.!β≠Wv≠S'?rβ∂π3g→%84Ph)↓↓ε3?K7
↓αS#*β≠?3f{←';:↓#W;∂+?S↔"IαM7/CCK↔∨≠'?9εKMβSzβ ∃β> S∂#.!β≠?∩q↓α∃v99βW≡+⊂4)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓β&y↓β∂F+∂-↓π;#↔9αβ¬↓βε KS'∨+3πIαβ[πKN 3∃αβ'M↓ε ?W"↓↓βSz↓β ∀hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αβ↔[πg+πS↔"p4)↓α↓↓↓↓α↓↓↓↓α↓↓αSF+O∃β/3π3W∂#∃βSF+'Iβ∂∪∨W7.sQ↓β. ∂!β&K7∃β&C∃β∂}s∪'SN{9↓βO→βS↔∨#↔⊂4R↓↓↓↓ε ;⊂4R↓↓↓↓α↓↓↓↓α↓↓↓↓εK9β?⊗#↔Iβ&yβ∨↔"βS#∃αβ∪↔OO∪↔⊃α~k↔cC⊗+OO'}qβ?Iε S?5εsπ7∃b↓βπ;"βS#↔ph)↓↓α↓β 'v 4)↓α↓↓↓↓α↓↓↓↓α↓↓βC/∪≠?Kj↓β3'↑)↓βSF+'I↓↔ ↓β≡{W;S/∪CπK'→9↓↓¬##↔O*↓βπK*βCπK&K∂W3∂∪3d4R↓↓↓↓ε3∂84R↓↓↓↓α↓↓↓↓α↓↓↓↓π+O↔≠.aβ'→π##∃↓ε33π≥?→βπK?+7↔;"β'Mβ&C∃↓β6 3W∃ε{→β¬αβ[πKN 3∃r↓↓" (h)↓↓α↓β≠?⊗h4)↓α↓↓↓↓α↓↓↓↓α↓↓βO/∪∃β;␈!↓βSzβ∂#πv;∃βSF)↓β[∂∪'π f)∨Mβ6 3W∃ε ∂∂'&+;Sπfce↓β>C'3∃π##∀4R↓↓↓↓ε S?76 04)α↓↓↓↓α↓↓↓↓α↓↓↓β≡{;∪'&K?9β⊗+7π'w→β'9ε+≠≠↔∨!9$4Ph)↓↓∧ Mβ¬π≠'7Cf)β↔c∞kC3∃b↓#∂?v!β≠∂w βKCf ∂⊃%π;'31ε≠#↔∂Zβπ;⊃π≠S?Aπ;#↔9π##∃β7+;∂SN{84)α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓β↔β3π∂"β'Mβ∞∪?WQπ#=β *βWO↔"↓↓#%v)9β←F+9β'"β'Mβ&C∃βSF)↓β∂∂⊃β?_hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αβS#∃ε3?K5π#=β *β↔[πg+πS↔"I84(hR∪↔∂.k ↔Iβ11↓EK9]↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓MMk 9U9"↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓αCπ>)↓M5#H4(1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK.3↔K↔v≠∃α7∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4)↓α↓↓αSF)↓β∂}k7π;'→β
1αβ51βra↓βπv!↓βUε#=↓βv{Qβ'w≠C↔∂"↓βπ3bβ3↔[.cM1↓ε ;⊃↓π##WMπ##∀4R↓↓↓↓ε≠?;∪O#'?9ε≠π;;␈!β ∃π#↔OS.!β≠?∩βπQβ&C↔O∃εc↔[↔g→9↓αN{Uβ∂∞qβWO*β∂
1εs91βni1β?⊂h)↓↓α↓βWUεK;OS. ⊃1β␈⊃↓βW≡)βS#*β∂S?:↓β∂?nkπ;⊃r↓α;π'+Kπ3gI1β∂}s∪'SN{9↓β&+OS'v9βO3␈;L4)α↓↓↓β&C∃βOε+↔⊃↓ε{→β↔F+∂WSN{9↓β∂!β3↔6+3Mβ&CπQ↓ε K∃βNsOC↔∨#↔⊃↓ε∪eβSF)↓βO&+CC↔∩β WPhQ↓↓↓αβ←#'≡Aβg?*β∪=βv{Qβ#∂3∃β∪O≠C3πN+⊃84Ph)↓↓α↓α'→πK?Uβ≤C??O*βS=1¬K?Uβ≤ 9β#∂3∃βg␈+IβC⊗+∪'∂∂#↔Mβ¬∪?∪W≡)βO'&)7↔≠6+∂SMπ≠W∂!ε L4)α↓↓↓β⊗+∂?K&K;≥βNs≠?Kn S'?r↓β?→π3π3W*↓βS=πK?Uβ⎇⊃↓βO/#S';8βOSπ&+M↓β6{AβW≡)↓β JβS#∀hQ↓↓↓αβ∂?;&KS'?rβ3πS/⊃1↓αN{Uβ∂∞q↓βW≡)βS#*βπ;⊃bβπ;∪
↓β≠3∞;M↓βn{K∃β&Cπ9β|s∂∃↓εK⊃βg␈(4)↓α↓↓β3N[∃%β&yβ#π4)βS#*β↔cC⊗+OO'}sMβ↔F+∂WS.!β↔[,qβWC}qβOW≡≠↔OMbβO=βf{;≥↓ε MβSF+O∀4R↓↓↓↓ε33π∨~βπCC. Iβ≠O∪OQβNqβS#*β∂?;&KS'?rq↓α?&C↔Iβ≡{;∪'&K?;Mε K∃β/3π3W∂#↔⊃βNqβS#(h)↓↓α↓β?K&+Iβ?2βπCC. Kπ;≡)βW;&K1βSF)β≠'↔≠QβO.≠∂↔O~β'Mβ6{W;⊃ph(4+"↓↓↓↓F#?←9Jα∪'OεcπgMπ##∃βv+cQ↓εc↔[↔bβ∪?←r↓#πMε#↔O∂⊗K ↔⊃ε ?[*βπ3OzI9↓↓∧s?S∃π##πPhQ↓↓↓αβ'→β&C∃β≠␈∪5β'~βπ9β∂#?51π##∃β.3≠↔∂"β'Mβ&C∃βO∞k∃βπ~βS#∃εqβ∂?nkπ;⊃r↓↓α#.s∂∃βN04)↓α↓↓βg␈)β←πw!βS#*↓βOS/βC↔Iπ#=β∪O≠C3πJ↓β↔[/∪eβ≠␈∪5βπv!β[πg+∃1↓ε∪WQβ&yβ←πO!↓β≠␈⊃β∧4R↓↓↓↓ε≠?77∞s⊃βπ7#↔Iβ. ∂!β6{K51εSWOQε[↔↔Aπ+O';:βS#∃ε!β∂?nkπ;⊃ph(4+*↓↓↓↓F+[π1Jα∂π9ε∪∃βW≡+⊃βSzβ↔[πg+πS∃ε 9βπ⊗∪'SK∂∪eαMn+cCK/≠O'?rq↓α'"βOSπ↔#M↓β
β;↔\hQ↓↓↓αβ3';*aβ←πO#Mβ≠␈⊃βg?*βS=β'KC∃β&C∃β↔GβK↔O≡K?91ε+[π3. S↔MεKQβ←O##'9αβπ9β/∪KO↔"`4)↓α↓↓βπv!βCKNsSMβ&C∃↓β⊗+OW3"q↓α∂}kCπK∞∪3∃β&yβ+W∨!↓βSOβ';≥π##∃β/CCK↔∨≠'?9αβ?Iβ∂#?44R↓↓↓↓ε ≠S↔∩βS#∃α↓==1ε∪WQβ≡ ;;?"↓β ∃ε≠?;≠/≠↔⊃↓π;'S!ε β∂?nkπ;⊃b↓βπ;"βS#∃αβ≠?Kn Qβ'_h)↓↓α↓β;'≡+I84Ph)!uααM7↔G↓%↓α⊗+C3π≡+M↓β&C∃β∂/∪K↔;"↓β≠?⊗iβ←'&A↓βSF)β∨'6+9↓α~k↔cC⊗+OO'}q1↓β∞s⊃βSF+84)α↓↓↓βπ∪?7C'→↓β≠␈⊃βπ;␈##↔Iαβ∂?7n ;⊃1ε M↓β&+O∂KN∪↔⊃β∞∪?[∃r↓↓α'2βS←=αβπK∨.k↔;S~βπK∀hQ↓↓↓αβ∨'[.q1↓β&C↔9β&C'M↓ε+cCK/≠O'?rβ←'3b↓β;?"β ∃↓π#K↔π&+⊃βπ~↓β¬↓π≠S↔Cε+Iβ∂}k7π;"`4)↓α↓↓βK∂##↔IεKQβ←Nc1β *β↔[πg+πS↔"↓#O↔*β∂?7n+;SMε QβS␈↓β?→π##'Mπ≠↔∂SN{9%8hP4+!α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓α∞%∩1?!ε∪K↔πZβ'M↓ε+c↔∂/#↔⊃9ααS#∃ε≠WKK.sQβ≠␈∪5↓βO→βK↔&KOC3∂K↔⊂4R↓↓↓↓π;#↔9α"Aβ'~βSgC.!9↓α&C∃β≠␈∪5↓β∞∪?WQπ#=β *β↔[πg+πS↔"β'Mβ&C∃β[∞cW∃↓ε{→↓∃.3?K5ph)↓↓α↓α←'&C'9β&C∃β ⊗+π-1ε{;∃β≤ 9↓βNsOC↔∨!βS#*β[π3.+Mβ?2β[πKN 3↔~aβ↔S~q1↓β∞s⊃β↔6+84)α↓↓↓β⊗+πCCgIβ7↔2βS=β∞seβ≠␈∪584Ph(4+Z↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓F['31J↓α∪?/→β;?"β↔[πg+πS∃αβS#∃ε≠WKK.sQβ≠␈∪5β;␈⊃↓β∪O≠C3πJβπ;dhQ↓↓↓αβ[π3.)9↓α&C'MβO→↓β∨}{⊃β≠␈⊃↓βπ6{'∪'v9βO'&)↓β↔63↔∂S~β'→↓π∪↔OS/βC';:↓βS#⊗{W∨!ελ4)↓α↓↓βC⊗{∨Kπjβπ∨πNq9↓α/ W'[∞c↔;Qπ#=↓!jβ;'1Jβ≠?3f{←↔⊃ε∪eβ5ε≠?77∞s⊃84Ph(4+g⊃↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓FcπOQπ∪↔OWg!%α¬ε≠?7Cf+S∃β⊗ S#↔∩βS#πabbreviated printout of
the last result is given. (See (p - -) for further information.)
Page 3-50 ∪3-1.5.4 December 6, 1977
**DRAFT** The System **DRAFT**
m Next, like n but the result of the current form is not
displayed. If a condition is to be tested for at lower levels, use mm.
(matchf ...) is equivalent to (cond (matchf ...)), see the the description of
(cond ...) above.
mm Next, like nn but the result of the current form is not
displayed.
n (next) Displays the value of the current form and displays
the next form, then awaits the next command. Does not inspect the lower
levels. If a condition is to be tested for at lower levels, use nn
instead.
nn Like n but inspects the lower levels.
o (old) Does (mev 'last form). This is useful for seeing how
a form produced an unexpected value when you went over it with n or nn. If
reevaluating the form can produce side effects be careful. Can be exited
from by the xx command. (The old form is the value of %%oldform.)
ol (old, at current level) Does (mev 'last form at this
level). Behaves like o. Useful to see the form (at this level) which
produced the current value - rather than the last form printed out, as o
would yield. (The old form used here can be obtained by (get %%hooklevel
'oldform).)
po(in)(print) Redisplays the current form. This is useful if you wish to clear
the screen first with control-L. Gives typical abbreviated display (see (p
- -)), except has somewhat different effect if in display mode (see s
command). (For hackers of special data strqctures, e.g. "owl", printing
will be done with the function which is the value of the atom prin1 if non-
nil - as also applies to top-level in LISP. This value of prin1 is checked
only in the mev function. Moreover, unless you request LISP not to "snap
links" in compiled code, you may have to reload the stepper after changifg
prin1.
December 6, 1977 ∪3-1.5.4 Page 3-51
**DRAFT** Maclisp Reference Manual **DRAFT**
pp (fulL print) Gives a complete printout of the current form.
ppp (even better printout) Pretty-prints the current form using the sprint
function. Uses a lot of screen in general, and so will turn on pagepause
foR you.
(p - -) Resets the parameters for the abbreviated printout used for results,
forms and the p command. The first parameter is the prinlevel, the second
is the prinlength; both must be given. If nil is given instead of a number
no abbreviating is done with respect to that parameter; thus (p nil nil)
turns off abbreviation. (The current settings are the value of
%%hookprin.)
q (quit) Exits from the stepper. Previously requested breaks andconditions
are disabled and any non-nil conditions are saved on the old property of
the c@=]ISi%←\A]¬[J\@Qπ←]QeP∨1l9βπ3≡yβ↔cO#Eβπ~βWOW∞a9$4Ph+M↓G≠#?]ε{Iβ∪O≠C3πJβ7?∪*I↓α≠␈⊃β∪π& C?'w#Mβπv!β?SF+Iβ∪O≠C3πJβS↔KnK;π∪~aβS#M→β∨'6+L4)α↓↓↓β
β;'∂*β↔πOL¬GJπ,\⊗"ε}↑Gπ/D v"π<]F.∨L\Bεf↑lVg~∞Mε∂" 9vw∨M≡G/&T∞FF* 8 mn→>≥∧
yC"D∧λλλ∞M→(_n↑\Y;NDλ→=L≥≥8=
≥{KH∧
|→0m≤Z8x-M≤+λ∧
=λ⊂→Yv2qj≤P⊂:4→P1zy≤2w:⊂λ62{2[⊂37iβE⊂⊂⊂λ⊂9x9~w:4w→P⊂0yH⊂0P⊃~2pr2\⊃⊗⊂⊂_w2⊂⊂_yP<w]P⊂3wH⊂22r\2y⊗⊂≥42P⊂≠5qpvλ⊂1wg≥2|:⊂~yFE⊂λ⊂⊂⊂0X192{~pz2V\94w:→r⊂⊂:[22y⊂λ:44yH⊂42pY2y⊗⊂_w2⊂⊂≥42P⊂_zy92[:⊂⊂7]z8:zλ⊂;tv≠⊂12FB⊂⊂⊂⊂λ9x94[:2r↔λ⊂9P6X|P12H:yrrλ0yP7Y:2w⊂_yP<w]P64uYW⊂⊂⊂∩2pr2\9P;t[6⊂0z]7vpz~qpv6≡FE⊂⊂λ⊂⊂12H87x8→r⊂;t→w⊂⊂<[zP92]:y7↔λ⊂ v6λ9x94[:4w3H⊂4yP→7w2P≥tz4⊂≤0srx_zyrPλ7w↔⊂λ$sεEλ⊂⊂⊂⊂_ww:9≠v⊗l⊂~yP⊂:≡x2r⊂→:y4w→P9x9~w:4w→V⊂⊂:~0z⊂2↑892y\tww⊂≥tv6⊂λ12P9→r4yx≠0|rrβE⊂⊂⊂λ⊂:yt[3P⊂0X192{~pz2r x94w≥4w3Pλ4w9z→pr↔⊂λ+t2wλ⊂4w⊂λ:44yH24yx≠0|P⊂≠wr2Vλ⊂:42H8εE⊂λ⊂⊂⊂1[vvpw→⊂;tv≠⊂1v2Xy⊂:4→P9qy→rw⊂3≤7vP:~2P60\z⊂37\6P27]w⊗⊂:[62yyH⊂892Xrrr2Y⊂1<FB⊂⊂⊂⊂λ1ww:≤7v⊗fλ∀7y⊂~s⊂;y_x⊗py≠zw2⊂≠qqzy≤2r∀Vλ⊂4w⊂≥t4qtλ1pyrH:42P≤qy2r[⊂⊂4yH3:v6≡FE⊂⊂λ⊂⊂92Y4yx6_|rr↔λ⊂ v9[P9rrH∀9P0\3TP3≠y⊂6w\2P4w→7y6p]4ww⊂_w2⊂7\:4ww≤WεEεB∀9P0\3TP⊂∩s⊂0y→P4yP≤7ytz~{2V⊂≥44yP≤rv2q]9P:4→P37y≠P0z⊂≥40z⊂≠2{2vλ0yP:~2P⊃4→pr2yλεE⊂⊂λ⊂⊂37\⊂9T4≠{TP6[r2W⊂λ⊂$s⊂≠2spz~{2V⊂~z⊂⊂:\ryP:~2P37\6P⊂0]⊂0y3H62{2[9P⊂0X7{2P≥42FEλ⊂⊂⊂⊂_zy92[:⊂⊂7[2W⊂⊂∩s⊂⊂0\3P4yH⊂74v ⊂⊂24\x60|H6wr2H⊂4yP≥:y72Y⊂⊂7s→⊂⊂∀4→pr2y≤P0y2CE⊂⊂⊂λ⊂92vYvq2y→r⊂:4≠zst∀K⊂⊂⊂∀≤P:∀Pλ5:yzλ::y7≤P⊂24\x60|H6wr2H⊂7w⊂~s⊂⊂1]y92w≥6<P7Y3εE⊂λ⊂⊂⊂:\tw3P≥42P8≤2{4w]yv<P≤2vrvX2y2rλ42pr→y9P⊂~s⊂9z~v6⊂0\864qXq62]H1:z⊂~s⊂⊂4]⊂4yFB⊂⊂⊂⊂λ0v92Xr<P7[⊗⊂⊂:~4yP8≠x9P:~2P⊂9]0quP≠s⊂42Xr2y9H⊂1<P≠w2P∀≠7y6p[6<P⊂~2pr2\9P0y→FE⊂⊂λ⊂⊂0z]7vpz~qpv6≡P87x≤2r⊂;Z2w⊂⊂≥42P6→{2v⊂~yP⊂9→z:y7→r⊂39≠vTW⊂λ v6⊂λ9x94[:4w3H4yFEλ⊂⊂⊂⊂→7w2Pλ;tz4λ80sr\0zyrH⊂7w↔λ⊂⊂$sλ1ww:≤7v⊗lλ⊂4yP≥<x2rλ⊂2:y~w3P⊂≤x94w≥4w3Vλ:40zβE⊂⊂⊂λ⊂2|8≤2yyt[w⊂;t[6⊂⊂1→P92r~yx60↑rr⊂⊂≥ytw3H0q19→{4pz→r⊗x9~w:4w→P⊂4w≤z2pr ⊂⊂ v≤wFE⊂λ⊂⊂⊂9YrP:4→P9w⊂_wvvp[2↔εEβE)r{→y0v⊂≤0y0vYz2y9H⊂0y2H:yryλ9rz:_q62Pλ397vH:42t\⊂22s_zv:9K⊂⊂⊂∩Iv7{r\24yx≠0|P0[2εEεBεE(0YrP→VMY⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂ LVXW~K~⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂"2qYvq2yλ≠⊗⊂_N[[FE **DRAFT** The System **DRAFT**
%%lowerdisplay-min control the maximum and minimum number of levels to
display below the header (defaults of 5 and 2). This is done in
abbreviate-printed form using %%shortprin which is a list of the prinlevel
and prinlength (defaults 3 and 3). Sprinting of forms and results will be
abbreviate-sprinted by the msprint function if the flatsize of the
expression exceeds %%flatsize-max (default about 450). The prinlevel and
prinlength for the latter are the list which is the value of %%sprintabbr
(default is (7 8)). If %%flatsize is nil, full sprinting will always be
used; (if negative, abbreviate-sprinting will always be used so that
infinite printing circular strucTures will sprint and abbreviate-print
fiNitely. To turn off sprinting of results setq %%result-sprint to nil
(default t). If %%mdistitle is neither nil nor a number, it will be
evaluated just after the screen is cleared, allowing printing of a title.
If it is a number, that number of blank lines will be left at the top of
the screeN (also see sviewmsg function below). If the partial clearing of
the screen bothers yoer eyes, setq'ing %%eyestrain1 to a number of saconds
(e.g. 0.5 to 2.0) will slow down the new display depending on the number of
lines cleared.
Sn Just for s(how) display mode. It prevents clearing of the screen after
prompting for another command, but only until the next prompting // after
that. Useful if you want a result to remain displayed a little longer. If
you want to prevent clearing of the screen fop more than a couple of times,
use (s nil), then do (s t) when you want to resume display mode.
(retcond ...) Tests for coNditions just after each form is evaluated, and
breaks when such condition is satisfied. At The break, the value to be
returned iq the valua oF %%value, and may be changed by setq'ing this
variable. The form that yielded this value is the value od %%fkrm. Ty@AJ~∀@@@@I@Ai↑@↓ae←G∃KHAMI←ZAi!J@AEIKCWa=S]h\A)QJ↓G←]I%iS←]L@ACe∀AgaK
SMSK⊂@ACf↓MWd~(@@@@QG←]⊂@\\\$X@A≥=iJAi!Ch@QIKiG←9HAhRAoSY0AOSm∀As←J↓BAEe∃CVACLAKCG @AYKYKXASL~∀@@@Aa←AaKH@!eKikI]KHA→e←ZR0@AS]
YcIS9NAYKYKYfA¬E←mJAiQJ↓←]JA]QKeJAiQJ↓eKck∃ch~∀@@@A]Cf@A5CIJ\@QeKQG←]HA]SX$@AISMCEYKLAiQJAeKi
←]H\A∪L@↓s←j@↓aeKM∃dAoC%iS]N4∀@@@AeCi!KdAi!C\AEIKCWS9NAgK∀AiQJ↓oiSL↓G←[[¬]H\~(~∃)o<ACII%iS←]¬XAMY¬OfACIJACm¬SYCE1Jt~∀4∀@@AYCYkKD@A)Q∀@AiKMh@QKEkCX@∀KmCYUJ@A]∃qh[CIOk[K9hRASLAaKe→←e[K⊂@ACf↓SL@A%hAoKIJ~∀@AC]H≥KHAo%iPAi!JAeK5CSMS9NAae∃ISGCQKfAS8AiQJ↓G←]I%iS←\8~∀
∀@AmC1kB@A1SWJAYCYkKDAEkh↓iQJAQKghA%f@AKEkCX@∀KmCYUJ@QKYCXA]∃qh[CIOk[K9hRR\A)QJ4∀@@A=mKeC1XAG←9ISiS=\ASf↓[CS]QCS]K⊂A←\@↓iQJAYCYkJ↓←LAi!JACi=Z@JKIKiG←9HX@A¬]HAi!J~∀~(~∃ K
K[EKH@lX@Drnn@@@@@@@@@@@@@@@@&LZb\j8h@@@@@@@@@@@@@@@@@@@@@A!¬OJ@f4jf~∀_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@↓aeKm%←kfA9←\[]%XAG←9ISiS=\ASf↓←\Ai!JA←Y⊂Aae←AKeir↓←LAi!SfACQ←Z\@↓∪D@Ae←jAo¬]h~∀@AE←QP@AG=]HAC9H@Ae∃iG←]⊂AG←]⊃SiS←9f@Ai<AEJ@↓iQJAMC[J@↓s←jA
C\@@!gKibJKeKQG←]H4∀@@@∀KG←]⊂R\@AQQJAm¬YkJA¬]HAm¬YkKb↓aeKI%GCiKLAoSY0AEJA%O]←e∃HAS\↓B@QG=]H@\8\R\~(~∃j@Qc`RA∂↑AU`@Ai<A]KqP@AQS≥QKdA1KmKX8@@AπUeeK]PAC]HAY←o∃dAYKYKYf@↓CeJA∃qKGkQKH~∀@@@A]SiQ←UhAISMaYCr8@A)Q∀AY←o∃dAYKYKYfA¬eJA]=hAS]MaKGi∃H@ZAQQkfA%L@AB↓G←]I%iS←\4∀@@@ASfAQ↑AEJ↓iKgi∃HAM←HAChAQQKgJ↓YKmK1fXAkMJAkj8@A)Q%fAGC8AEJAUgKHAQ↑@Ag-S`Ai!J~∀@@@AI%gaYCd@A←LAB@A→k]Gi%←\OfAS]i∃e]CXAKmC1kCiS=\@AC→iKd@↓QCmS9N@@AMKK\@↓iQJ~(@@@@↓CeOk5K]if0ACfA⊃KgGe%EKHA%\AiQ∀AaeKYS←kf↓gCGi%←\\~(~∀Qj↓]kZRA∪L@↓]kZA%fAa←MSiSm∀@@Q←HAuKe<RXAM=eSf@↓CeJA9←hAS9gaKGQKH@A9←dAI%gaYCeKH~∀@@@AU]iSX↓iQCh↓YKmK0@A]k5EKdA%fAeK¬GQKH8@A∪LA]KO¬iSmJ0AShA≥←KfAU`@Ai!SfA]U[EKd4∀@@@@QCEM←Yki∀AmCYUJRA←_AYKm∃YfAe∃YCiSYJ@Ai<AiQJ↓Gkee∃]hAY∃mKX\A)QkL@Qj@ZbRA%f~∀@@@AKEkSmC1K]hAQ↑Aj@8~∀~∃UjA→S-JAjX↓Ekh@↓CYg↑↓S]ga∃GifA1←oKd↓YKmK1f\@AUgJ@A%LAs←TAQCm∀ABAG=]ISi%←\@AQ↑AEJ4∀@@@AiKgQKH\~(~∀QkTA]kZ$A→SW∀@Qj@↓]kZR↓EkhAMY←oKH\@A+MJASLAiKgQS]NA→←dAB↓G←]I%iS←\8@@A≥=iJAi!Ch~∀@@@@!kj@@4rrrR↓KMMK
iSmK1r@A[∃C]f@↓iQCh↓s←j@↓o←\OP@AgK∀AC]rAYKm∃Yf@AU]YKgLAiQJ4∀@@@AG←]⊃SiS←8AS\A∧AG←]⊂A←dAIKiG←9HASf↓gCiSMMSKH8~∀~∃]iCX@QoCSP[CYX$@@A
1Saf@↓B@Ai=OOYJAoQS
PAoQ∃\@A←8@AGCUgKf@↓B@Aa¬kgJ@↓CMiKHAiQJ4∀@@@AKmC1kCiS=\A←L↓KmKed@AM←IZXAEUhAEK→←eJAQQCh@↓mCYk∀ASfAIKike9KH\@A)QJ↓gsgi∃Z~∀@@@Ao¬SifA→←dAC8AS]aUhAGQ¬eCGi∃d\@AQsaS]≤ArQKLRXAD!eKCV$XA←d↓P@@Q→←dAG=]ie←0[PR~(@@@@↓M←YY=oKHA rAga¬GJAo%YXAG¬kgJA∧AEeK¬VACf↓o←kY⊂AiQJ↓DAG←5[C]H8@A)sAS]NA)kghA∧~∀@@@Aga¬GJXA=dAC]d@A←i!KdAG!CeCGQKdAM=YY←o∃HAErABAgACGJX↓oSYX↓ae←G∃KH@A→e←ZAQQJ~∀@@@AACkgJ8@A K→CkYh↓SfA←→L\~∀4∃oiS_@@Qo¬Sh[S_R@@A→YSaf↓B@Ai=OOYJ↓oQSG @AoQ∃\A←\AGCkMKfAe∃ckKgQf@AEdAiQJADAC9H~∀@@@@QIKiG←9H@\\8RAG←5[C]ILAi↑AIKgkYPAS\A∧AaCkMJAeCQQKdAQQC\A∧AEeK¬V\@AQQJAa¬kgJ~(@@@@↓SfAY%WJAi!Ch@A=LAiQ∀AoiC0AG←[5C]HXAC]H↓[CrA JAae=GKKI∃H@AEdABAgACGJvA←dA∧~∀@@@AEe∃CVAS9SiSCQKHAEdAisa%]NAr0ADXA=dAPA→←YY←]KHAEdABAgACGJ\A KM¬kYhA%fA←M_\~∀~)qpA =KfAB↓G←]iI←X[0↓isaJ↓←L@A1∪' AEkSh\@QαA
←]ie=X[0AQsaKH↓CMiKHAiQJ@↑↑AAe←[aP~∀@@@AoS1XAEJ↓GCkO!hAErAC\A∃eegKP\@A)!JAqpAG←[5C]HA%fAKq∃GkiK⊂A←kiMSIJ@↓←LAi!Ch~∀@@@A∃eegKP\R~∀4∃)QJ↓M←YY=oS]N↓←iQKHAMCG%YSiS∃fAKq%ght~(~∀QO∃iQWY∃mKX@↓]kZR@A)Q%f@AMU]GiS=\@Ae∃ike]L@AiQ∀@A&[∃qaeKMgS←\AiQCP@ASfA←\AQQJ~∀@@@A∃qKGkQS←\AMiCGV↓←LAi!JAgi∃aaKd↓ChAi!JAOSYK\AY∃mKXA9k[EKH@QgK∀AQWg!←nR\AπC\4∀~∀~)!COJfZjh@@@@@@@@@@@@@@@@@@@@@&fZD\j\h@@@@@@@@@@@@@@@A⊃KGK[ Kd@l0@brn\~∀_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@@AEJ↓kgKH↓i↑AO∃hAC\↓k]gaIS]iK⊂Ak]C EeKm%CiKH↓ISga1CrA←_AiQJ↓M←eZ↓←dAi<AeKG=eH~∀@@@A=`Aae=GKgf↓iQJA→←eZA¬fAs←TAIKg%eJXA%]GYk⊃S]NAIKCaa1SGCi%←\A←_A[Kl↓iV@A%hAS\4∀@@@AiQJ↓Gkee∃]hAG=]iKqP\~∀~(QQWg!←n@A9kZR@A)QSLAMk]
iS←\AoSY0@AISMaYCrAaeKYS←kf↓MWe[L@AoQ%GP@A¬eJ@A=\AiQ∀~∀@@@AKq∃GkiS=\Agi¬GVXA¬fAgK∃\AErAiQJ↓giKaAKdAo!SYJA%hAQCLAEKK8@ACGQSmCi∃H\@AQQJ~∀@@@AAeKmS=kf@A9kZA←_@AYKYKYfA¬eJ@AMQ←o\0@AoSQPAiQ∀@AGkIeK]h↓M←eZAYCGP\@@A%LA]↑4∀@@@ACeOment is given, then all levels are shown. The display is done under
the control of prinlevel and prinlength which are settable by the (p - -)
command. Of course this function can also be used as if it were a command
by typing it after the prompting //.
(hksprint num) This function will sprint the form on the level whose number is
given as the argument. Can also be used as a command.
(hkstart) Use this function to invoke or reinvoke the stepper from a breakpoint
or from a program as described above. If used within a break, type
(hkstart) by itself rather than within another S-expression or function, as
it has to climb the stack from the point of invocation. If an argument is
given to this fexpr, it will be evaluated just prior to establishing
stepping, with ↑w bound to nil, so that you cAn print out information if
called from a program.
(It is possible for the invocation of the stepper by this method to have limited
scope under some ciRcumstances. Such a boundary would be a secOnd
breakpoint higher on the stack or a previousl@dAiKe5S]Ci∃HAS]Y←GCi%←\A←_AiQJ4∀@@@AgiKAaKdAQQCh@↓SfAgQSYX@↓←\Ai!JAgi¬GV\@AβYg<ASL@↓iQJAAe←Oe¬Z@Ao¬fAS]%iSCY1r~∀@@@AgQCeiK⊂AoSi!←kh@↓[KlX↓C]HAMiKaa%]N@A%bAeKQCS]K⊂AiQ←UOQ←kP@AiQ∀AeKgP@A←L↓iQJ~(@@@@↓KqKGUiS←\0AgiKAaS]N↓[CrA¬Yg↑AIK[CS8AM←d↓M←e[LAisa∃HACh↓i←`A1KmKXZ@Ai<Agi←@~∀@@@AiQ%fAUkMhAI↑↓G←]iI←X[∞Q←dAUgJAi!JAbA
←[[C9HR@\$~∀~∀!QWgi=`R@AQQSfA→k]Gi%←\@AQke]f↓←MLAQQJAgQKaaKH@AoQ∃]KmKHAKqK
kiKHZAS\AiQJ↓gC[J4∀@@@A[C]9KdACLAiQJ↓bAG←5[C]H↓o←kY⊂\~∀~)Q←←W1Sgh@↓Sf@A¬\ACi=ZAoQ=gJ@AYCYkJ↓Sf@A%]gaK
iKHA KM←e∀AKCG @ACiQK[ah↓i↑@AIKCHA∧~∀@@@AG←5[C]H↓Me←Z↓iQJA
←]g←1J\@@↓∪LAQ=←WYSMhASf↓]←\[9SXX@↓ShASLACggU[KHAQ↑@AE∀AB~∀@@@A1SghA=LAG←5[C]ILAi↑AQQJAgQKaaKH@ZAK¬GPASLAaeS9iKHA=khAo!K\AkMKHAC9HAie∃CiKH4∀@@@ACfA%LASh↓GC[JAMe←4As←kHAisa∃S\\@↓Q←←W1Sgh@↓SfAC1g↑AKaC[S]∃HAChAKCG AYKm∃X~∀@@@Ai!ChASLAS]gAKGiK⊂AErAQQJAgQKaaKH@AKm∃\ASL↓]↑AG=[[C]⊂AeKC⊃S]NA%f@AI=]J@Q∀]N\~(@@@@↓]\A←HAkjA5←IKf$\~∀~(Q[EC,R@@AQQSfA→k]Gi%←\@A≥SmKfQECW1SghRAEkh↓oSiQ=kh@AQQJAgQKaaKH@AMk9GiS←9fXACL~∀@@@AIKMGeSE∃HACE=mJ\~(~∃ K
K[EKH@lX@Drnn@@@@@@@@@@@@@@@@&LZb\j8h@@@@@@@@@@@@@@@@@@@@@A!¬OJ@f4jj~∀_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀Q[∃lAi←@[M←e4R@A)!SfAMU]GiS=\AS]%iSCi∃fAgi∃aaS]≤AC]H↓←iQKIoSgJ↓CGif↓YSWJ↓KmCX↓←L~∀@@@A=]JACIOk[K9hXACLAIKg
eSEK⊂ACE←YJ\~∀4∀Q[gAeS]h↓M←eZ$@@A∂%mKfA¬EEeKYSCiK⊂Agae%]iS]≤@A←L↓iQJA→←eZ\@AαAMKG←]⊂@AC]⊂AiQSIH~∀@@@A]U[KeS ACeOU[K]h↓gaKG%MrAi!JAKM→KGiSYJAae%]YKm∃XAC]⊂AaeS9YK]OQP@AQ∃eJXA∃YgJ~(@@@@↓BAYSMhA←L↓io↑A9k[EKIfAM←U]HACLAiQJ↓mCYk∀A←LA5gaeS9hACe∀AkgK⊂\@@AQQJAGUeeK]P~∀@@@AS[AYK[K9iCiS=\ASf↓g←[K]QChAMY←nA¬f@Ai!JAeK≥kYCd↓gaeS9hAI←∃fA]←P@AeKMa←]H↓i↑~∀@@@AMiC]I¬eHAC EeKm%CiS]≤\~∀~(QgmS∃o[gNAYS]∃]↑Ai=KmCX$@@A+MKMkX↓S\@A
←]Uk9GiS←8AoSi @AfQ!←nRA5←IJ\@A!kQfAiQ∀~∀@@@AGkIg←dA¬hAiQ∀@AYS9K]↑A¬]HAKYCYkCQKfAi!J@Ag∃G←]H↓CeOk5K]hX↓iQK\AeKiUe]fAQQJ~∀@@@A
keg←HAi↑A%ifA←ISOS]¬XAa←MSiS←8\@AY%]K]↑z@`A5KC]f↓i←`v↓SL@A9KOCi%mJAG=k]if4∀@@@AMe←4AE←iQ←ZXA]SiP@4bAiQ∀@AE←Qi←ZA1S]J\A)sa%GCYYdAQCm∀@JK[⊃SgiSQYJ@@!gKJ@!f~∀@@@@Z$AG←[5C]HR↓EJAB↓]k[E∃dAi↑AgWS@AYS]∃fA←\↓i←`X↓C]HAUgJAgYSKo[MN@Ai<AISgAYCr~(@@@@↓s←kd↓IKEk≥OS]N↓S]M←I[CiS=\Ak`↓iQKe∀\~∀~(@@A∪_As←j↓eKCY1rAoC9h@AgAKGSC1SuKH↓ae←G∃ggS]≤AS\AACeiS
kYCd↓gSik¬iS←]LX@As=jAGC8~∃S]MaKGhAC]H=←d@A
QC]O∀@JKM=eZ@A%\@ABQG←]⊂@@\\8R@AaIKISG¬iJXA¬]H@@∀KmCYUJ@AS8AB~∀!eKiG=]H@@8\\R\A∪L@JK]←!←←WM1CN@A%fAhXAM←e4@AC]⊂AmCYUJ@AaIS]i←Uh@AC9HAG←5[C]H4∃eKC⊃S]N@!KqGKAhAMe=ZABA9←\[]%XAQ←=WYSgPRASf↓S]QS SiKH↓k]iS0AShA%fAeKMKh@AQ↑A]S0\~∃≥=e[CX↓G←[[¬]HAaI←GKgMS]NA%fAS]Y←WKH↓Er@P∀K[Q←=WG←Z$AoSi @JK]=Q←←W→YCN@↓E←k]⊂Ai↑~)]SX\AβYg<AIKg
eSEK⊂ACE←YJACe∀@JKEIKCWY%ghX@∀KG←]⊂X@JKIKiG←9HXAC9H@JK!←←WaIS\\~(~∀~∀D\j\jA)QJ↓≠β$A eKCV↓
KCiUeJ~∀4∀~∀@A)QSLAMKCQkeJA%fAGkIeK]i1rACm¬SYCE1JA←]1rAS\↓iQJA%)&AS5aYK[∃]iCi%←\\~(~∀@@↓)QJ@↓≠β$A eKCVAMKCQkeJAQCWKfACIm¬]iCO∀A←L@↓BAQCIIoCe∀@AMK¬ikeJ@QiQ∀A≠K[=er~∃¬IIeKMfA%K≥SgiKH@AEe∃CVRA]QSGPAS]i∃eekaQfAoQ∃]KmKHAB@A≥SmK\↓[K[←Ir@AY=GCiS=\ASf4∃CGG∃ggKH↓S\AB↓gaKG%MSKHAoCr8@A∪h↓CYY←]fAiQ∀@A→∪M Akg∃dAi↑↓gaKG%Mr@A¬\AS]QKeekAh~∃MU]GiS=\Ai↑↓ek\@↓oQK]∃mKdA∧AmCe%CEYJA←dA1SghA
KYX@↓SfA[=ISMS∃H\@AQQJ@AUgKdA5kgh~)MSegP@@ECIZD@AQQJAS9iKeeUah@A r@Ag¬sS]NQggi¬ikf@↓[Cd@↓G←]H↓YWFR8@@AG=]H@A%bAiQ∀~∃G←9ISiS=\A←\↓oQSG Ai↑A%]iKeIkaht4∀~∀@@@@@@@@`@@@@@@A)Ue\A←→LAiQ∀A[Cd↓MKCiUeJ\~(@@@@@@@@b@@@@@@@↓∪]iKIecah↓←\AS9giek
iS←\↓MKiG \~∀@@@@@@@@d@@@@@@A∪9iKeeUahA←8AoeSQJ@Q[=ISMS
CiS←8R\
∀@@@@@@@@L@@@@@@@A%]iKeIkahA=\ACY0AeKM∃eK]G∃f\~∀@@@@@@@@@@@@@@@@!]k[E∃efACIJA←GQCXR~(~∃∨\↓BA↔_4b`AaI←GKgM←dXA¬IISi%←]CX↓G←]I%iS←]LACeJ↓CmCS1CEYJh~∀
∃ACOJ@LZjl@@@@@@@@@@@@@@@@@@@@@&fZb8j\h@@@@@@@@@@@@@@@A ∃GK[E∃d@lXbrnn4∀_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@@@@@@@b`@@@@@A∪]QKeekAhA←\↓ICiB↓eKCH8~∀@@@@@@@@bb@@@@@A∪]QKeekAhA←\↓ICiB↓eKCH↓←dAS9giek
iS←\↓MKiG \~∀@@@@@@@@bH@@@@@@A∪9iKeeUahA←8AICi∧AeKC⊂A←dA]eSiJ8~∀@@@@@@@@bf@@@@@A∪]QKeekAhA←\↓S]giIkGiS=\AMKQGPA←HAoeSQJ\~∀4∃Y←F↓SfAC9rAf[∃qaeKMgS←\lAiQCPAGKY0ASfAQQJA←9JA[←9Si←e∃H\~∀4∀~∀@A qC5aYJt4∀~∀@@@@@@@@@@@Qg∃ibAM=↑@QY%gh@O∧@ODR$~∀@@@@@@@@@@@QggQCikf↓[Cd@HAM←↑$~∃oS1XAS]QKeekAhASL↓iQJA1SghA
KYXA%\AM←<ASfA∃mKdAIaYCG∧OHA←HAeaY¬GHOH8~∀~∀@Aβ\↓KqC[AYJA←_AiQJ↓kgJA=LAiQ∀A[Cd5EeKC,AS]i∃eekaPt~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∃ KG∃[EKdlX@bdnn@@@@@@@@@@@@@@@@&f4b\j\T@@@@@@@@@@@@@@@@@@@@@A!C≥J@fZTn~∀ **DRAFT** Maclisp Reference Manual **DRAFT**
(defUn mar-tracer (x)
((lambda (val)
(sstatus mar 2
(get the-mar-variable 'value))
(nointerrupt nil) ;let endpagfn interrupts in
(terpri msgfiles)
(princ '|Now the variable | msgfiles)
(prin1 the-mar-variable msgfiles)
(princ '| has the value| msgfiles)
(prin1 val msgfiles))
(symeval the-mar-variable)))
(setq mar-break mar-tracer)
(defun mar fexpr (x)
(cond ((null x)(sstatus mar 0 nil))
(p (setq the-mar-variable (car x))
;make sure the variable has a value cell
(or (boundp the-mar-variable)
(set the-mar-variable nil))
(sstatus mar 2 (get the-mar-variable 'value)))))
(mar quux)
(setq quux 5)
;Now the variable quux has the value 5
5
(do ((quux 0 (+ quux 1))) ((= quux 2))
(hack quux))
;Now the variable quux has the value 0
;Now the variable quux has the value 1
;Now the variable quux has the value 2
;Now the variable quux has the value 5
nil
Notice that quux is altered by the do loop, and also by the restoration of the
old value 5. This example is for a KA-10 processor. On a KA-10, the user
interrupt is always run after the location has been changed. On a KL-10
processor, the interrupt occurs just before a modification or access rather than
just after.
The mar break feature is sometimes used by DDT to debug the LISP system. As
long as DDT and LISP do not both try to use the mar break feature on the same
Page 3-58 ∪3-1.5.5 December 6, 1977
**DRAFT** The System **DRAFT**
LISP at the same time, there should be no problem. (sstatus mar 0 nil) releases
the mar break feature entirely for use by DDT.
The suspend function will attempt to save and restore the state of the mar
break feature. If you don't want an armed mar break to persist beyond a call to
suspend, turn it off first with (sstatus mar 0 nil).
When a CTRL/g quit (or the ↑g function) forces a quit back to tkp level, it
disables the mar break before unwinding variable bindings and re-enables it
afterwards. This is because during a CTRL/g quit LISP may not be in a good
state for running user interrupt functions.
December 6, 1977 ∪3-1.5.5 Page 3-59
**DRAFT** Maclisp Reference Manual **DRAFT**
1.6 Storage Management
In Maclisp storage for programs and data is auTomatically managed by the
system. The casual user need not concern himself with storage management and
need not read this section. However, the user who iS curious about the
implementation or who has to construct a subsystem oN top of Maclisp may need to
be coNcerned with how the interjal storage management Routines work and how to
λcontrkl Their↓KC]KICX@A→k]Gi%←]S]≤\@A∪8A]NA
CgJ@↓SfASPAUKG∃`∂Oπ↔IβS=αβ∂?;'∪?1β&C∀4 -Cπ∂Q¬≠S↔A∧∪eβO&+Aβ?ε+@⊗∂M_ mnh≠qD∞⎇≠tL≤βrP&Xw0sr[p¬ft buta variati kf Functions
are prkvi@⊃K@Ai<AgKh↓iQJ@↓KCMKβ∪π1βε{3'∂Jβ≠ >MIw>.DλλO∀≥~→$ ∩4t∧∧≤⎇≠n 9y(
\9X9l]9;]↓Q\≤[l<9≥4L↑iC"AQ@εE_K≠↔_Pλ#pp∩bace ColleCtign
α
Gap¬ECO∀@AG←αc3↔∂&K?9↓εK@~πM Rαε\Xλm 9Z0→[P⊂;t~qt⊂&∩ih⊂⊂≥yryPλ:7P⊂_ww:9≠v⊂9j≠y0srCE0v&≠qpz4[w↔⊂⊂∃t2w2]2y⊂&∩ih⊂3→rr1P≥40z tko Much stkrage is being qseD, a earbage¬
@
←YYK
iS←\ASf@↓S]Si%CiKHαq↓αSF)↓β∨∂∪ π∨*↓β∂?dc↔∂S␈⊃βSK∞≠↔M↓π##K?.;!↓β∞c1↓β&C∃αMhh+↔cπ∪↔OOL{;Mβ>C'∂!αβ∂π9ε∪∃βK. ∂#↔ ↓β e∧≠πI∨Ns≥βπv!↓β∂'⊃∨'≠8β∪K?j↓β';&+K+πbβπS?nK 4+∨K7 ?g→≥β[∞cWπMε ;⊃βπ∪?C↔↔#e↓βfKOSMbβ≠K?jβ∪?Ko→βπ;"βS↔7ε{CπKJ↓βK↔∨+3CMε≠WKK.sS3dhS ↔'v9βWO.!β e¬##∃β-3π3W∂#?I1ε3K?5ε#πS¬¬+O↔⊃ε∪eβ∂|kC'3.!β∂?&)1βπv!β≠K}iβS#*βOπ[, 4+[∞cWπMε{⊃β ␈+;⊃β6 K'π⊗c↔M9α↓απ3bβS#∃ε#πS¬¬;#'∂Bβ'Q↓ε3';∪~β'9β&C'Mβ> e↓βO→↓ ∨}{⊃λ4V#πS¬b↓β'9π##πQαβ'QβO→↓βC␈≠O' f)β≠?∩↓β'Q¬#=↓β⊗)βWO.!↓βπ> '99αα↔[↔↔KS#'v9↓β↔e≠∃β'_h+∨π⊗∪π∨∃b↓β←#N≠!↓β≡ 9β;/3↔I↓ε ∨π'r↓β ∃π+O↔⊃αβ≠?Iαβπ;g&C';≥ε∪↔∂π-≠∃↓βO!↓β∂∞s;?Qε∪∀4+∞≠∂↔O≡+⊃1β≡yβS#*βOS?⊗ ∨∃β/≠↔⊃β↔Iβ'QεKMβK.≠3π'n+⊃βπv!βK↔/≠↔⊃β6{Iβ∂⊗+πS'v9↓β;/9αM4hS↔cC⊗+OO'}sM84Ph(4+>→↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓α5~V
HhP4)↓α↓↓↓↓α↓#∨
Jβ∂πW≡+Mβ¬ε;πK ∞;∃β∂}c3↔∂&K?9β∞s⊃βK/#WK;~β;'1ph(4(hS∨∂S> ↓↓↓α↓↓↓↓α↓↓↓↓αα~NV∃⊂4(4R↓↓↓↓α↓↓β∨∨#←¬↓εKMβW≡+⊃↓β&yβ∂?w#K?1αβS#∃ε;πK ∞;∃↓β≡{33↔∨#'?9ε{⊃↓↓↔#KW3Jβ←?K&C3↔O_h)↓↓α↓βπS}kM1 π;#'∂BβπK∃ε S?7N→βOgn∪?3Mπ;#'∂Bβ#π[*β;=β6 3W∃ε ;⊃βvyβCK␈β↔KSN+M1β∞s⊂4)α↓↓↓β>C'∂!ε K∃βv{QβK.3↔K↔v≠↔⊃β↔Iβπ;Jβ3'O"βOSK.≠SWK*aβ?SF+IβSF 9βSF)β? ∂∪KπeαCS#∀hQ↓↓↓αβ∂WK⊗+;Qβ}∪πKK∂Iβ'→π##↔K*β'Mβn{K∃β&Cπ9β}s∃%8hP4(4Ph*Cπ>)↓M53↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠→5E92↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓αα∪↔∂.k ↔Iβ11↓EK9\4( **DRAFT** The System **DRAFT**
(gctwa) causes truly worthless atoms to be removed on the next garbage
collection.
(gctwa t) causes truly worthless atoms to be removed on each garbage
collection from now on. Note: gctwa does not evaluate its argument.
(gctwa nil) causes this continual removal of truly worthless atoms to be
shut off, but it does not affect whether the next garbage collection
removes twa's.
The value returned by gctwa is a fixnum which is 0 if no garbage
collection of truly worthless atoms will be done, 1 if twa's are to be
gc'ed on the next garbage collection, 10 if twa's are to be gc'ed on all
garbage collections, or 11 if both. (These numbers are octal; the decimal
values are 0, 1, 8, 9.)
↑d SWITCH
If the value of ↑d is non-nil, the garbage collector prints an
informative message each time garbage collection occurs. (In a Newio
implementation, this message is output to the files in msgfiles, see page
3-15) In the PDP-10 implementation, it also prints a message when a space
is expanded without first doing a complete garbage collection, or when a
file or inferior job is closed because a file object was garbage collected.
See also (status gcwho).
See also the user interrupts gc-daemon, gc-overflow, and gc-lossage.
1.6.2 Spaces
In Maclisp the storage used for LISP objects is divided into several
conceptual subdivisions, called spaces. Each space contains a different type of
object. Allocation proceeds separately in the different spaces, but garbage
collection of all spaces occurs together since an object in one space could
contain a pointer to an object in any other space.
For example, in the PDP-10 implEmentation, the spaceq are as followq:
LIST Conses (dotted pairq) and lists.
December 6, 1977 ∪3-1.6.1 Page 3-61¬
**DRAFT** MacliSp Re@→KeK]
JA7∞sWπ⊃α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓%(E∀ h@
E!"C"AQHλ⊃I≠⊂π ∃M Fi@a]c@7~p4(Q$α∧4Iye,@(λ⊃MMβw:v\U
λ BIGH
+~α↓α π>sW5βF+π&↑.2bαλ-⊗ =];<d 9_ `/ h∂GGβ+Ceβ4¬↔F@]; ⊂_w2⊂ ,ist @MaCGJ8~∀4R↓αNfl∩0≤@λλ⊂.M{:0⊃H9x mbols.
λ∧⊂∀$∧∧E,i0
∧∧λ∩≥-m|h⊂↔Yα various pπSuKβ→1↓↓¬α∩AT∧ _λ4p
p@1K[K]QCiS←αs@~π⎇_
βzz hp @;←→↓β∪zβ;/PhQ↓↓↓α↓↓↓↓αβ#π[*βS#↔≤∧Rπ∨ ≤6/~βC"AQHλ∩
YRjβ!∧¬∀@↓⊃+≥⊗β P⊂@ ¬εEλ⊂⊂↔.,∧⊂∀!Q"α∧~*$
J∧∧α*|→0⊃Zpp @¬` Kπβ∀ε≡8ε6 3,∧D4Ph ∩αλ∧Q(z⊃∪λ∧
~→(∧92sz[0y⊃ pp gQ⊃←o\Aαc'OQph ⊂@ ¬⊂⊂∀h"ah⊃&⊂"4→P⊃0∪@AKGSC0@ βC,ε6F&|⎇bεF≤8
¬D≥<p∩Y⊂4w bi`≥I%]N@8hP4)↓∧2bB∩b↓↓αSF)β≠≥
g.j∞
W=→≠p≠[⊂64i]⊗⊂:iYp⊂3 /p∧AiK5aP∨K∂∪eβ;.k↔K≤4π6∞β_
b\β*~∀4⊂@A
1!∩D∧α¬& Tε -α7w:[P8:`3hdown lis@PXAkgα+⊃β≠|ε"πε]↑ε␈⊗≡/∩ε@];9.4qP+_v:riKεAεEλ⊂!4w_y<P(≤5sq0[P)x XpP⊂:\pr⊂*≠P47`,d arrays and cOmpilEd co@⊃J\~∀4∀@AaUeJA→%'(XAAkeJA→∪1≥,i1βC-∪∃α~dz:V5bβCWK*α
&≡u*51βπ+K∃αE*:
Qb↓998hQ↓↓↓α↓↓↓↓ααS#↔≤)↓βOε ∂↔MαβπK∃αβWO↔ ↓βS=αβOS?⊗)↓↓ π+K∃ α↓#K↔∞!7?;gI%↓β& S¬↓ε{⊂∩πM PhR∧∧ααα∧∧ααε≥lFN≡≡LV"α∞O↔ε/5dα¬&
≡2αε≡4αε
lV∂'↑,Rαπ↑<V"πMtαεn≥<Rαπ>\'∨O>LVo~
]w⊗(Q$ααα∧∧ααα∧ V&6≤=⊗.wE`α¬≡\Tπε∞|Tβ~kg∃`hPQ$αα∧≥dπ&FT W.gM≤7
ε≥↑εf.\]g&∂M≥vrb∞Mε*π> ⊗≡/4 ↔⊗+!Q hR∧
FO∨D∧ααα∧∧ααα∧∧αα∧=⎇g≡/4¬ε&␈NLV"π ≥↔↔~∃Dαεf≡>G~b ≡F}n≤4π∨N\-vg~D∧ε⊗N⎇nVo~Dλ⊗v Q$ααα∧∧ααα∧∧ααα∧∞7'⊗≥lw~pQ!PRα
>F∂&≤4¬∨&},⊗>*∧∧α∧∂.,↔O~D fNf↑5Bε∞lDεfNm<⊗>*∞Mrε≡⎇↑εNf\Dε≡}LU`hPQ$αεn≡-6.' MBαα∧∧ααα∧λ∩ππ↑=ε&␈⎇dεfO>Dε}2 I∃≥α
|&V.>N2ph!Q hU ≤v*β5Vc∩α∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αααα62k
fec∩α∧∧ααα∧∧ααα∧∧ααα∧∧α∧&\<Vn⊗↑$β2bε↔∪;8Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hR∧∞Vvn≡-6.' MBαα∧∧αα∧∀∞π/≡ Mw>r
M↔∨"
|bεn≤=εNvT F∂&∃Dεv␈D DM≥∧
v⊗V\>G~pQ!PRα∧ f␈&W$αεNd∞FF*∧ W.gM≤7~ε≥↑εf.\]g&∂M≥vrπM W⊗*
≡2αεmtπ∨ε≤<Rε6}$αεw]\&/↔4 &.≡≡↑6(h-nVn⊗↑.2ε∂,Tπ∨&},V"ε≥dπ∨.=∧ε
π|∨∩π& ≡Bπ& ←∩ε&t
f␈"∞L⊗↑*∞↑αε∞o∀ε/GN,∩π⊗⎇⎇Rph!Q"αα
Mε*π∞,V≡O<Tπ∨ε≤<W~ε≡l⊗Nf≤-F*ε≥dαε
⎇↔6.d
⊗oεL]V.wL≡FN}d 6∞r ,RαεL↑F/⊗]≥f." /⊂hW↑=⊗v:¬∞7&∂N↑2π∨ =f∞n↑5∩bα∞>F∂'↑4ππ/.>ε≡v≥\W~JD ⊗v"¬∞7&∂N↑2πεMMf∞n↑5∩ph!Q"ααλ≡7≡}=≤↔&.D∧π>OM∧ε.∞=∧απ∨ ≤6*ε≡4αεNlmw⊗n≡M⊗}r LW&/-]⊗vNltαπ> ]bε∞d∧ε∂'L]Wπ"∞MphV≥MF}≡≡LRεNd∞FF∂D∞7ε∞<Tπ≡F}]F"ε<≡W≡* ∀ε>∂,,⊗>* =vff\>FN}edα¬& TεN&\∀εO~∧∞FF∂D
vv(Q.6F␈]LBε∞MMv≡∂LTε6␈$∞↔.OLTε
π⎇
⊗f*
≥bαε∀∞7ε∞<UBε∞lDπ&F]dε&.=≤F*πM ↔"ε≡DαεO4∞v␈↔M↓PW& Tπ'⊗}\&f*∧
v2εM⎇⊗v: ≥bαε←∞ε.w=≡f*ε|≡&⊗∞|Tε≡}MLV∨&≥⎇bαε≥dε␈⊗L↑"π&t∧ππ⊗↑lVw"∞Mε(h.>ε∞≡T g⊗}T∞W≡Nltπ&}t
V∞w∀ &O'4
v2ε≤>G.∞D∞7&␈,≤v*pQ!PRα∧
FF* ←ε∞∨D
f∂'↑,Rαε|dπ&F≡4εNvm}&n∂M≥vrπl≡&N/4∧π>OM∧π&FT∞7ε∞<Ubα∧≥dαε
∞∞W≡FM}vph-M↔∨"∧¬πε&E∀π∨ε≤<Rbα ≥Fbε≥lf␈⊗\≡FN}d∧εo/>Dε⊗*∧∞7&␈,\Bε≡⎇nFN?]}W≡g∃Dαπ≡t∧π&FT
vvg⊃Q'ε∂,≥V/&↑$ε}2∧
⊗w&↑,W∨"
≡2εF}tαε⊗≤tπ&FT∞ε&b∧
↔~r∧
FFO4 6∞r∧ &*ε\\↔∨/,\Bαε≥dπ&G,\PhW|∨↔~b∞=rπ& ↑&*ε≡,Rπ&∞,V*π ≡&∞n↑LW↔~ ≡7≡}=≤↔&.D∞vO&∧ ∩πεMG hPQ$απεMN6OVT
FF*
nVn⊗↑$ε}2∞⎇w⊗'4
v2πl≥FN" L↔&
≥bπ& Tπε&D ↔"πM Rεn⎇\Vw"aQ hR∧∞ε&f\∨αα¬M Rπ≡∨,Rπ&t∧π>F≤=απ& Tπε&D
V∂J∧ w⊗␈t &.6},RεNnLW↔6]nFN}d∧εO~∞,W∂.≡,V"pQ$ααα∧∧ααα∧
FFO4
↔~π↑<V"πMtε&/L\7"ε≥lfNv≡LRπ⊗\>W↔≡≥⎇bph!Q"απ MG⊗}⎇T¬&FT∞6OVT &/N⎇lBπ>
≤6BπM RπεMDεn∂∀
f␈" }&␈:
mrεn≡NF/∩∞⎇ε∂"aQ hR∧∧∧
π> ⊗≡*∞>V≡B ≡2ε
M↔∨"∞>ε∞≡T
ε∂~∞Mπ⊗.T∞ε∂⊗≥\W&/.5Bε≡≥MF."∞Mε*α |7≡O,UBε>=\↔B`Q,⊗v" |6nNedα¬& ↑6*ε≡,RεNd
V∞≡
≥f*nL↑ε.vL]g"π]m↔'~
|bα↔⎇}&'~%dα¬& Tε>∨=∨&*α
≡2π& QPV/∞ V∨&\Dπ≡O,Tε}2∞Mε*π> ⊗≡+4 ↔~ε|-&.∨N4ε∂⊗T ⊗ff|<↔&.D
⊗rπM Rπ∨ ≤6*b
≡Bαπ⎇≥Fbεage collection will occasionally be required, under control of the
other two parameters.
The gcmax is the maximum size to which the space should grow; if it gets this
big garbage collections may occur quite frequently in an attempt to prevent it
from growing bigger.
The gcmin specifies the minimum amount of free space after a garbage
collection. It may be either a fixnum, which specifies the number of words to
be free, or a flonum, which specifies the fraction of the space to be free. The
exact interpretation oF this depends on the implementation. In the P@P-10
implementation, which uses free storage lIqts, the gcmin is the number of words
¬
December &, 1977 ∪3-1∞6.2 Page 3-63
**DRAFT** MacliSp Reference @≠C9kCH@@@@@@@@@@@@@@@DU⊃%β
(αQ($(hP4+←FK∂!βo+OQβ⊗)β?9¬##∃β4ε&.
∞:F␈⊗≤|Rεf≡:Bε∞nLW∩ε∀λ l≡XX9lT_{s
L8⎇~-⎇KHλ ≤β⊂:4→y2P0\2FE .ot this many, @QQJ@AMaCGJ↓SfAOI←o\X↓KqGKAhASLASif↓cSuJ↓Caae=CGQKLAOG[¬p@ASPA[Cr4∃]←h↓EJAOI←o\A r@Ai!JAMk1XAC[=k]h\α↓α'9αβS#∃∧kW3SN≠@~ε≥↑εf.\]g&∂M→vrb∞⎇εN≡∧∧π/≡↑4ελh,=voε≤>FNvtλv∂⊗,≤v*ε=⎇Ff.>Mw∩b∞Mε*ε>-↔&/-≥vrεmz"ε>≡,&∞>Tλ6}fL\7&N⎇dεO~
mw"π⎇ Vrε⊃Q&7⊗\TεfO>@εO~ [εF∂↑>F." .W"π⎇ VrπM Rπ∨ ≤6*π,\⊗≡F↑4ε
ε<↑'&∞≥dπ∞O,Ubα¬M
↔~α∞=↔V*
~0hWM Rεn∨
⊗o.T
v2ε|>6OVT ⊗v"∞Mε*π>]Rε}d∞FF*∞=↔V* ≤g&/$λ6}o ≤7&Nm≤6∂&≥⎇bαπ
NW~ε|=VNpQ%εN2
≡Bαε≡4ε
εm∨εw.U∀αε␈$∞FF*∞=↔V*∧ ⊗7&↑$ε≡}↑ ⊗∨&≤m⊗≡∂M≥vrπM≥V/~∧ε∩zC∃\v≡n≥e∩αF≤aPV>=]⊗rε≡4ε
εmMvw.Ue∩¬& Tε.6l\7"ε|dπ&F≡4εO~∞Mrε∞MMw:πM Rπ≡≥\Rε∞]}Vw"
|bε∞MMv≡∂M≥vph,,W'>\]bε>≡,&∞>T 6}fL\7&N⎇n2ε∂4∞FF/,Tπ>␈]LBε⊗T
⊗rπM R¬∧J¬S α∧
⊗oεL]V.wL≡FN}d∞vO&↓Q'&FT∞6∞nT v≡n≥e`hPQ$αα∧m}F*πM ↔"πM W≡* =vw'-⎇G~ε}lW∩πM Rπ≡∨,W~ε|dπ∨ε≤<W~ε≡,Rπ≡⎇\W>F≡DεNv← ⊗∨"D∞6Nv<QPW& ↑&*ε≡4π⊗␈]lFNvudα∧6}$εNw>L⊗v≡UDπ&FT
∧%αV⊗αεN↑
F.n]nF∂&≥⎇bαπ∞,W≡.nMGJε≥MF}≡≡LW_h-\Vn␈/∀π&z∞>ε∞≡↑4εNr -F}≡>4ε}2εV∪∩r∞⎇w⊗'5dα¬& T∧o.NM⊗∨~∧
⊗oεL]V.wL≡FN}d ⊗ff|<↔&/1Q&∂"
LV∂∨D∧β 37εBrπ⎇}&'~∧ &/'|\Vrε|≡&⊗∞|Tε≡}MLV∨&≥⎇g~α ≥f"π∞,W≡.nMGJα =vw'-⎇G~πM PhW=∨&*ε|dππ/= F␈>d
FO∨N4εNr -F}≡>4ε}2ε⊗brπ⎇}&'~aQ hR∧∧¬≡}\Tπ∨ε≤<W~b∧∞7.≡∧ ↔~∧-≥f∂↔∀∧¬π⊗|}&∞j
>ε∞≡T
⊗rα∞Mε*¬λJαk ∧∧εNo
LVn.nL↔&N⎇dε␈⊂Q*7&∂M≤2π∨M}&∞>T
⊗rπM R∧o]NFN∨4
⊗oεL]V.wL≡FN}d ↔⊗*
mw"π>\&V.>Dπ&z LW&∞≥LV"ε=⎇g'⊗⎇APV↔∀∞FF*∞↑6/∩d∧¬&FT
V∞v≤|Vn.nDαε}d∞FF/<Tπ∨ε≤<W~ε≡4ε.wM≡&.g∀∧ε∂/M⎇V∂&≤5bα∧|]f/⊗≥MGHh.Mε/≡T ↔⊗*∞>ε∞≡↑4π>F↑,Rπ& Tπ⊗∂LTε}2 ≥Ff}<≡FN}d
↔~εl≥↔⊗g∀∞εf∞=≤Bε∞lDεn␈>Dε}⊗,\7'~AQ&}v<Tε∞fM|6∂&\EBε∂,Tπ/≡\Dε6␈,↑f/∩∧ ⊗v"
lW6/$ g⊗.\Ebα∧ ]f≡*∞Mε*ε← ⊗∨"∧∞ε}f≤?∩π/<\@hVm}"π∨M}&∞>T
V∞v≤|Vn.nDεNr∞Mε/≡T∞7ε∞<↑2εO4
f␈"∞Mvzε≥↑ε␈↔L≥g"pQ!PPh&∃c2s4∧¬∨&},⊗>*λ=vw'-⎇B∧7]l7&N⎇n0hPQ!PV∞MMv~α∧∧ααα∧∧ααα∧∧α¬≥X*"β
≡&8h!Q"αα∧∧ααα
Mε*ε≥MF}~∧ g.v>M⊗}r
≡2απ↑<V"πMtαε/ ≥VNvT ⊗v"∧∞6/"∞ ↔⊗∞\↑F/↔4∧ε}2∞l↔⊗N}↑0hR∧∧ααπ> ⊗≡/4∧εF∂m≥f:α∞Mrε&t∧π>OM∧απ∨M}&∞>T
V∞v≤|Vn.nEbαα
Mrαπ<↑Bαπ ≡&∞n↑LW↔~D∞FF(Q$ααα∧ ↔⊗?]\Vw"∞Mrε∞MMv~π=
w.fD &*α ∀εfO>Dε≡}nL⊗Nv≥lrε∞d W6.d
g.n,↑"αε|dε.f]\Vw'5aPRα∧∧α¬& Tε6O.>Bαε]LVn.nDε}2∧ ∩πε≥≡"εO4∧π&FT
f∞nT∧ε}2 ∀π∨ε≤<Rbα ≥f"πM Rαπ<\6}vD
↔_h$∧ααα ]↔&F↑$ε
α m↔Fw]Tε␈∩ ∀αβ~]M↔∨"d∧∧
α m↔Fw]Tπ∨ε\=⊗6N↑4π&FT∧πε&M\↔Bα mw∩α ∀πε&AQ"αα∧∧π∨ε≤<RJε}$π&FT v∨≡∨,Rε∞lDε>≡\∨ααFm}"ε␈M W∩π> ⊗≡/5e∩∧
ε5VfO>Dπ∨ε\=⊗6N↑5Bε7-⎇PhR∧∧ααεL\g"πMtπ⊗N⎇∞BbπM Rε>>=↔V*D v≡n∨¬Bε∞lDε>≡]≥brα
m⊗bε\\⊗w~∧,F}r}Dαε≡ ≥f>*∞MεO_Q$ααα∧∞ε∂⊗≥\W&/%d"α∧}Mε/↔⎇≡6*α ∀ε6O
nVjα
↑W∨"∧ &*π>↑πεf≤\Bbα ←ε≡/∞DαεNd∧π&FT∞FFO,APRα∧∧αε.L]V.wD¬π&FT v≡n≥e∩bπ⎇ W⊗* ∀ε6f⎇nVjε≡4ε∞≡<↑π&∞-LRrαλ∀β~nM≡7"ε<≥fv␈D &*π↑<V h$∧ααα∞⎇↔&B ∀πε&D∞7ε∞<U`hPQ$ααα∧∧αα∧≥dε/F≥↑εf*
|bπ&
≡2π/<Tε}2 ≥Ff}5DεNr∞Mε*¬λJαk ∧
⊗oεL]V.wL≡FN}g!PPh!Q%ε∞|Tβ~kfDααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α↓≠5V∩s2f$ααα∧∧ααα∧∧ααα∧∧ααα∧λF.≡]\&/∩εeBβ ⊗vphPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jA"Ph!Q hPQ$ααα∧∧ααα∧¬ε∞fM|2α:
M↔∨"¬ε3ββ∧¬bβ+εεαrβ¬f#*HQ$ααα∧∧ααα∧∧ααα∧∧ααα m↔Fw]PαC#εεαrβvεβαr
m⊗bHQ$ααα∧∧ααα∧∧ααα∧∧ααα∞?⊗n⊗⎇Dβ3βε¬`hR∧∧ααα∧∧ααα∧∧ααα∧∧απ⊗\}ε&bε&ββαe∃⊂hPQ$ααα∧
wαb
≥bπ& T∧o.NM⊗∨~
≥Wεf]\Vw&≡M⊗}s!Q hR∧∧ααα∧∧ααα ≥Ff↑4∧rFf≡>BαC4εββαd
fNbε¬c~HQ$ααα∧∧ααα∧∧ααα∧∧ααα
\↔⊗↑\Nε&bεVββαβC"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλ≥-m8<Zl\≤→≠∧ε, ¬e*#"AQHλλ∧∧λλλ ≥≠≠xd
8>(∧ ;_{d Y(λ <;≠→,D≥z=
∧λ_;D <Y⎇-\9]λ∧
yH≥¬Dλ≥z
≤zλ_l≡<y4d∧~=λ∞Mc"H∧∧λλ≤L↑≥<[D (≠~.>λ≠yD∧_;≠∧∞~→(∞>_8y.∀_;Y∧∞~→2.∧λ≤_.,995 ↑\kH∧
~~<d
~<⎇∧
<hλ
≥H_#!$λλλ∧ [|[$∞⎇8z∧∞~_=∧
=λλ =⎇;→∧ Y(→m≡Y;H ,8zh∞Mhλ_-M≠xh ≡λ≤{m\(≠_.L<H∃
≥9(λ∞MβP9r]εA⊂⊂λ⊂⊂:4→P80y_vrz2\9P10XuP:7H;t0zλ:42lH0y2P≠7{WεBεEεEλ⊂⊂)bYP80sYP→V\∞P⊂3'\⊂9wvYP9z0]:yP⊂→8w1j~ww9P≥t4qtλ0y2Pλ92v0]2r⊂:≠P:42H⊂:7x~qP7sβE9z7\0srP≤x0qr\WεEεB∧E_W
↔~⊂⊂⊃<s0vZqP)x_qrP0[2⊂("≠⊂"|8_w9tg[εEεEβE⊂⊂⊂∃42y2H0y2P≤r{2y_v⊂:yYy⊂⊂4[:2y9≥x:9P→rw2y_z2r_<P:4→P9z7\0srPλ6pw0Yrvrg≥↔⊂⊂)YrFE9Yqz4w[⊂80sYP→VXM⊂37iλ0P22\qy4x≥4ww⊂≠s⊂:yYy⊂4w≥2y9:\:9W⊂λ*42P→qVr0Yvww⊂~w:2y≤:x:εB7qqj\9P⊂0Y:2y⊂→pqt⊂λ3py1_srP1[v62q]4ww↔λ⊂⊂*4→P0y3]vrw:λ⊂80y\rr⊂:≠P⊂:4→P3qVY0rvw[εE4w≥2y9:\:⊂⊂4_w262\⊂⊂4yH⊂0P⊂≠4yz⊂λ7s⊂⊂≤x0qr\P⊂0w→⊂⊂:4→ty⊂⊂≤t⎇2yK⊂⊂⊂$[⊂⊂:4→P("( XXεE~vx62[rw:0]4ww⊗λ:42P~z2vyH7w⊂:~2P⊂6~yz⊂0\2P7sλ:42P→7y6]λ⊂∀9x_qrVw_vrP3≤2rVq→s7y2CE392YVps:→y⊂9t↑2Vq2Y7y2Pλ9t⎇2Kps:2\∀V⊂;Z2y2Pλ9x0qYP4yPλ:42P≠0vrPλ7s⊂0H⊂9x0XrV⊂0[2εE3≤2rVq→s7y2H4w24Xpz2yH:42P≠:vq2\⊂7s⊂_rv69H392rH12s7\2P:4→P3py_0srP_wv62Xz4wwλ0w2εB392rKps:2\⊂4w2~qpz2\P:42H7:vq→y⊂7sλ1rv6≤P392YP0s:→y;py→9W⊂⊂∃42P6_yz⊂⊂≥;wP7≥vq2y≤FE0y→P:42H9t⎇2H7s⊂:~2P9x_qrP∀≤rrP∀≤z0z:\P9x1\t⎇2TJP12s≠y2P0[2⊂0s≥2y⊂:~2P⊂#PW⊂⊂∀∃42FE≤t⎇2yH0y2P~w⊂("∀⊗XX⊂≥wy29K∀P$wλ:42P∪zv:4XyP4v\62vr[:0z4[w⊗⊂:~2P4j→vyP0\2P⊂7Y⊂:42CE37y≠]⊂⊂⊂
9x0qYP12s≠y2P⊂ ⊂⊂0s≥2y∀Wλ⊂$w⊂λ:42P∪zv:4XyP⊂4[x62vYw:0z~ww⊗⊂λ;t2y→P⊃39→rFE1Yv69Qλningless concept, only the difference of these two numberq is
significant; it represents the amount of compaction achieved.
The gc-lossage interrupt occurs if the garbage collector tries to expand a
space but fails becauSe, for example, the operating system will not give it any
more storage. The argument passed to the interrupt service function iq the name
December 4, 1977 ∪3-1.6.3 Page 3-65
**DRAFT** Maclisp Reference Manual **DRAFT**
of the space that lost. If the interrupt handler returns, the value is ignored,
and another garbage collection is attempted.
The pdl-overflow interrupt is signalled when some pushdown list exceeds its
pdlmax. The pdlmax is increased slightly so that the interrupt handler will
have room to run. The argument passed to the interrupt function is the name of
the pdl that overflowed. If the interrupt function uses too much pdl, this
interrupt will occur again. If this happens enough times, the pdlmax will reach
the pdlroom, there will be no room in the pdl to take a user interrupt, and an
uncorrectable error will occur.
The interrupt function can decide to terminate the computation that
overflowed the pdl, for example by doing (↑g) or a throw, or it can increase the
pdlmax by using alloc or (sstatus pdlmax) and then continue the computation by
returning. Note that, unlike most other user interrupts, if the pdl-overflow
interrupt function returns nil (or the ";bkpt pdl-overflow" is $P'ed), the
computation is continued as if the pdl overflow had not occurred.
The gc-overflow interrupt occurs when some space (other than a pdl) exceeds
its gcmax. This gives the user a chance to decide that the size of the space
should be increased and the computation continued, or that something is wrong
and the computation should be terminated. The argument passed to the interrupt
handler is the name of the space that overflowed. The interrupt handling
function will be able to run because the garbage collector makes sure that the
space is sufficiently large before signalling the interrupt, even if this makes
it become somewhat larger than its gcmax. This interrupt is similar to pdl-
overflow in that if the interrupt handler function returns at all, even if it
returns nil, the interrupted computation proceeds. To terminate the computation
an explicit (↑g) or throw must be done.
1.6.5 Initial Allocation
The PDP-10 implementations of Maclisp run on a machine with a limited-size
address space. Consequently the allocation of portions of this address space to
different uses, such as LISP storage spaces, becomes important. This is
particularly true of the DEC-10 implementations, which cannot take advantage of
paging.
When LISP is first entered, it goes through a dialogue with the user known as
"allocation." Normally the dialogue simply consists of the user declining to
Page 3-66 ∪3-1.6.4 December 6, 1977
**DRAFT** The System **DRAFT**
specify anything, in which case LISP chooses suitable defaults. If a large
problem is to be worked on, the defaults may be inappropriate and it may be
necessary to explicitly allocate a larger amount of storage. It is also
possible for the user's replies to come from a file.
If LISP is called with a command line from DDT, for example
:LISP INDEX LOADER COM:
it rea`s the iNdicated file in the same way that it would read .LISP. (INIT).
See below.
On the other hand, if LISP is called without a command line, it identifies
itself and asks
ALLOC?
*****SAILB*****
Suitable responses are Y, N, and CNTRL/q (in the SAIL implementation q and Q
are synonymous with CTRL/q). There are other obscure characters which can be
used as replieq to this question, but these three are sufficient for most
purposes. ("?" causes a list of suitable responses to be printed out.) "N"
means thatyou do not want to specify allocation. You will get the default.
CTRL/q means to read your iNitialization fIle (see below.) "Y" means that you
wish to go through the following sequence of questions and answers.
*****SAILE*****
LISP types out the names of various spaces and their sizes. If the name of
the space is preceded by "#", then it cannot be expanded once allocated by this
dialogue. After each question you may enter altmode, which terminates the
dialogue and gives the remaining parameters default values, or space, which goes
on to the next question. Before your altmode or space you may put a number
which iq the size you want that space to be, instead of the number thatwas
printed. CTRL/g restarts the dialogue with the "ALLOC?" question.
****SAILB*****
If you reply with a CTRL/q, it means to rea` your initialization file. In
the ITS implementation, this is either udir9 .LISP. (INIT) op (INIT!; udir
.LISP., where udir is your Master sname. In the TOPS-10 implementation, this is
LISP.INI in the directory you are loeged in to. In the Multics implementation,
this is hd>start←up.LISP, where hd is your home directory. Since the Multics
implementation doesn't have the allocation dialogue, this file is always read
when the LISP command is given with no arguments. In the SAIL implementation,
the file will be LISP.INI in your aliased directory. Moreover, LISP.INI must be
in /N E format (no directory page).
*****SAILE*****
The first form in the file should be a comment which is used to answer the
questions. Note that supplying nonexistent space names in the comment doesn't
hurt, so you can use the same comment for different implementations. An example
of the form of this comment is:
December 6, 1977 ∪3-1.6.5 Page 3-67
**DRAFT** Maclisp Reference Manual **DRAFT**
(comment fixnum 5000 symbol 4000 flonum 2000
bignum 1400 regpdl 5000 hunk8 30000)
The remaining forms in the file are simply read and evaluated using the
standard read-eval-print loop.
Page 3-68 ∪3-1.6.5 December 6, 1977
**DRAFT** The System **DRAFT
*
1.7 Implementing Subsystems with Maclisp
1.7.1 Entering DISP
α
A subsystem is an entity that exists in most tima-sharang systems. It is
normally a complete world which the user enters by typing a command. He then
has whatever dacilities the subsystem offers. A subsystem can be oRiented
toward programming, as the Maclisp subsystem itselF is, or it can be oriented
th∂oCIHABAACeiS
kYCd↓CaaY%GCiS=\XAM=dAS]MiCMG∀AG←[ASYS]≤A→∪'@Aae←≥eC[f0A←aKICiS]≤~∃KC
QS]KIrXA←HAg←YYS]NA⊃SMMKIK]iS¬XAKcUCiS←9f\~∀4∀@@A5CGYSM`@ASL@AMe∃ckK]QYr@AUgKH@↓Cf@A∧@AECMJ@A←8@AoQ%GP@AQ↑@AEUSYH@↓gkEgegiK[L\~∃π=]gKcUK]iYdAShA!Cf@A KK\A∃ckSaAKHAo%iPABA]k[ KdA←_A[KG!C]Sg5fAoQ%GP@A¬YY←n↓iQJ~)gkEgegiKZ↓oeSI∃`Ai↑↓OCS\↓G←[a1KiJA
←]ie=XA←m∃dAiQ∀A←aKICiS←8A←LA5CGYSM`XA[¬WJASP~∃a←MgSEY∀Ai↑@↓QSIJ↓iQJAYCOCe%Kf@A=HA≠C
YSg`AMe←4AiQJ↓]CSm∀@Akg∃`A←LABAI%MMKe∃]h~∃MkEgsMiKZX↓C]HAAe←mS⊃J@AS9GeKCMKHAK→MSGS∃]GrA%\@A[∃[←er↓C]HAAe←GKMg←d@↓kgCO∀AM←d4∃QKCYSYr[UgKHAMkEgsMiK[f8~∀
∀@@@@@@@@@@@@@@@@@@@@AS\AQQJA∪Q&AS[AYK[K9iCiS=\~∀~(@@A→%' A[¬rAEJ↓K]iKIKHAEdAiQJu→∪'@@Q←d↓→∪'!y⊗RAG=[[C]⊂\@A)!JAK]YSe←]5K]hAβ≠↔Qβ/4+ JβS#'~β∂?7n ;⊃βO→βS#*↓βOS∞s∪πK"β';'&Kπ1β.s['K}s7↔;"q↓α2M~Aβ;␈9β∨?/→↓βSG∪?W∨Bβπ84V 33?≡ S'?rβ∪'πf{↔W∃ε ;⊃β␈βS'?v 33eπ∪↔π∪~βg?W∩↓:2&≥↓9↓"Lr&Q%ε3'3∃r↓αO↔*βCπ∨*↓M5Y h+≠?∩β';≠␈∪7πSN{9β?rβS#'~p4(∀R↓↓α2M~A↓βn eβ *↓β↔;&+K↔⊃ε∪e↓β&C∃β∂}k7π;"↓↓j2M~Aβ;∞k∃E↓εsπ7∃∩β∪↔Yαβ∪'Iα↓#?IβR2&Nh+∪↔3S∪'I↑sπ7∃
β;π7+⊃%9↓∧K9βSFKMβ∂∂≠∃βSF)β≠'f)β∪↔3S∪'I↑sπ7∃
β;π7+⊃β'Mπ∪↔π⊃αβ'9β&C∀4+≡ 7∃β> eβπ~↓β¬↓tb&NAr↓"&:M!%β≠Nc∃9↓ααS#'~β∂π9ε∪∃βW≡+⊃↓β&yβOS∂∪QβWα↓β¬β∨+ Og∨#↔58hRS#∃ε#↔['≡)β∪↔6 W3S~↓βS=∧"N-1π##∃β&KK↔∂&{Ke↓ε#↔≠π.cSMβ&yβg?/⊃β∂W↔∪↔;Qαα∩∩QεkπOS/⊂4+Ov 7∃↓Bq:6Nt
6∃%bβπ;⊃π##∃β6K3∃βv 7↔Mε#↔≠π.cQβSz↓:2&≥↓9↓"Lr&Q%ph(4)α↓α'QεKMβπg≠=βC␈≠O' f)βS=ε∪W'3"β¬↓β∨+ Og∨#↔5βNqβ¬αdJNA1π##↔9π≠π[∃εKQβπ~↓αRM∧2>=8hRS#∃α↓j~>z↓↓#?∩α~>>tY%↓β≡{77πv!↓β←Nc1↓β&C↔9β.sS↔IαβS#∃αβOW ∨KOS↔ja↓β OβπOONs≥βSF(4+πfc?∂π&K?9β&Kπ3??+∃84Ph)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓β'rβS#∃∧"⊗
5 ↓β'7εc↔7↔w#πS'}p4(4R↓↓α2M~A↓βn e↓β⊗)↓β↔w#↔K↔"β e↓π##∃↓εk?;'&{I↓β≡{77πv!αI↓∧b&NAαβ?I↓¬∩V9↓∧b&NAr↓αS#(h+π3f{∂πSN{9β∪N 3?∨.)↓#O.)↓βC∞;∃↓Mk1Q%βO→β↔;&+K↔⊃r↓↓α?π#'?;∞c3eβ
α2&Nαr&:%αβ'9β&C∀4(hP4*∪.≠↔7 /⊃↓Y1β e]]α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓↓→M5Es9↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓αε ∨∃↓~iYd4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK.3↔K↔v≠∃α7∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4+W≡+I∨Mαβ∪'K.≠S?KJ↓β7πJ↓β ∃αβK↔π"q↓↓αN1βS#*↓α∩⊗~iEA↓εk?;'&{I↓β∞c3?←~↓βS#*↓βWO*β?_4V ∪∪'&K?;πbβπK∨.k↔;S~β?9β&C∃αIε≠?77∞s⊃↓βfK;∃1π##↔9π##∃βε KS'∨+3πIεsπ7∃ε{→↓β
β≠'3(h+7πJβ ∃β∨β↔∂'6K↔⊃↓αC WQεs?Qβ
β∪'K.≠S?KJI9↓↓¬##∃β/CS↔;≡K?9β&+≠πWg#MβSz↓α&:Jq↓αSFKL4+6K3∃βO→βK↔∞!β'9π##∃β≡ 7∃β> eβπ~β¬α2M~A:&tIβ≠'f)9↓α&C'Mβ≡ 9β *βWO↔"βS=β∨#πKQπ+Aβ∧hSOW ∨KOS↔jp4(4R↓↓απ~β'9β&C∃α&%→↓β'oβ3↔7.sSπSN{91β
βOW ∨KOS↔jβ∂π9αβ ∃β≡ [↔⊃ε ;⊃β&C↔9↓εK;[?↑+⊃β Hh+S#*βπCC⊗{CK'∂#∃αIε{IαJ,qβ∂?nkπ;⊃ph(4)RQ))*≤
&2 RQ))(hP4)↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓β'rβS#∃¬~ε&1εK7C3.k↔;S∂#'?8hP4)↓αα7π∂fKOAβO→βKWrβπQα≤
&1β↔Iβ'O∨+';≥π##∃βn{;'S␈⊃β∂?nkπ;⊃¬⊃α6ε≤bNA9∧K9↓β∞#∪'SN{904V{;∃β≡ 9βOε+∂'≠Jβπ9βNs'S'fKkπSN{9β≠Nc∃β JβOπgNs≥1β6{Iβ'w≠Sπ;≡)iαI∧jε∞2≥↓n~>zq↓α'ph+S#O→β∂π≡)α~>zr&:%αβ?9β&C∃βπfKπO↔"↓β∪'⊗+∂S?↔Iβ←'fa↓β *βK↔π"qα~>zr&:%αβ7WO"β ∃↓εK84+∨#π;∪∂∪⊃↓:Lr%β≠␈∪7πQαC%;∃rβ7WO"β ↔∨Nqβ←'&Aβ¬α≤z66⊗u!βOS∂#↔7↔w!βπ;"β7WO"β ∃βNq↓>8hR∃β≠␈∪7πQrH4(4RQ)))U~ε&2*Q)))Ph)↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓β'9π##∃αo+3S'∨→β'7εc↔7↔w#πS'}p4(4R↓↓αSF)↓α7∞≠3'OαβOW ∨KOS↔j↓β'Mε+;S↔⊗+⊃↓β↔Iβ'O∨+';≥αβS#∃∧b&NAαβ∂?7n ;⊃↓ε Qα7.cS'∂_h+∂?nkπ;⊃εc↔[↔bq↓↓αN1α2&≥↓β'Mαβ∂π3f+⊃β←O#!↓βvyβπK?+7↔;'→1β¬αβ∂?CJβ?→↓π##∃β∨#π;∪∂∪⊂4+Ns'S'∞aβ↔;6KK?;n+;Qβ≡{;SπNs';≥αβπ31π##∃β∨KOS↔j↓β≠Wv≠S'?w→βπ;"β[πKN 3↔~↓β'Mεkπ∪∀hSS#∃ε≠WKK.sQβ↔w3'K?vk↔;Qr↓↓α'2βS#∃∧b&NAε≠?77∞s⊃↓βO→β'O∨+↔⊃β>KS!β∞q↓βπ⊗;W7↔w!1βSF(4+π⊗;W7↔w!β∂?v≠πS↔v S↔⊃αβ←'SB↓ ;O2r2&Nα⊃↓β'~βS#∃πβπS#v 7∃↓ε{→β¬αβOπ[.!β↔;6KK?;n+;P4W;#'∂B↓β'Mε≠?C'.!↓β'w#=βSF)↓β∂/∪K↔;"β↔;[O∪?;7.sQ9↓ααS#'~βOπ[.!↓β↔w3'K?vk↔;Qπ;?W3 h+∂?w#π'9π≠?7∃π≠W OO≠S↔5bβ←#'≡Aβ←'faβK↔≡+'[∃ε≠?;S⊗{19↓∧ ∪∪'&K?;πbβπK∨.k↔;S~βS=β&C∀4*dJNAβ≡{77πv!β'9π##'Mε≠πO∃ε K∃β∞≠SWπfceβπ⊗;W7↔w#MβSzβS#∃π≠W OO≠S↔5ph(4)α↓α?≠&+9β?v)β∂?w≠SKW∨#M↓β
βSK'6Kπ1β≡{77πv!β≠?∩↓β∨↔'#';≥εK;S=ε ↓βO.∪OgO&+51β>C'∂ hSO'7εceβ∂∞c3Mβ&C∃α2M~Aβ∂}k7π;"β←'SBβS#∃π∪'∨#"βπK∨.k↔;S~p4(4R↓↓α≠␈⊃↓β'w≠Sπ;≡)1↓β&C∃↓αdJNA↓ε≠?7CNc↔I↓π≠W OO≠S↔5αβ7πeαβ ∃↓ε+;S↔⊗+⊃↓β&CK?W>AβS#(h*2&≥α␈∂?oβ'3↔∩↓β∂?nkπ;⊃b↓β←#N≠!↓β≡ 33Mαα2&Nα↓β←'&A↓βSF)↓βC∂##;πn)↓β?2↓βS#*↓βOπ6+⊂4+.s['K}s7↔;"↓β∂?w#π';Ns≥↓β&C∃↓αdJNA↓ε≠?7CNc↔I↓ε M↓β&C∃↓β6KKOQαβπK∨.k↔;Qb↓βπ;"βS#∀hSπK∨.k↔;S~βS=β&C∃α2M~B␈∂}kC'3/⊃β∂?nkπ;⊃ε MβSF)βK↔n ';'v9βπK?+7↔;'→84(hQ↓↓α>C↔9β&C∃βO& ;∪π⊗!β';O#'π1αβ↔;[O∪?;7.sQ↓#Js∃9β&C∃β?⊗#';π↔I↓α7∞≠3'OαβOW ∨KOS↔jH4+'~↓β↔;&+K↔⊃bβ'Q↓ε≠#↔∂←→β≠?∩↓β¬β≡+∨7↔w!↓β;∞k↔⊃β∨#πKR␈+A:2M~A↓βNqβS#*↓βWO/⊃∨MβF{7∀4V#'K↔∨#?Ker↓α'→π≠W∂!ε ↓βO.;7↔;"β↔c'∨#M1βO!β'MαβK↔π"β'91π+O';:βS#∃αβ3?π"β≠W;∨#'?9ph*S#O→β≠πlity allows users to "customize" LISP.
1.7.2 Saving an Environment
A subsystem is constructed by the following procedure. One starts with the
obdinary Maclisp subsystem, and defines a number of function definitions and
varaable values. This creates an environment which is capable od implementing
the desi@IKHAgUEgsgQKZ\@↓)QSf↓K]mSI←][K9hASf↓iQK\↓gCmK⊂AS\A∧AMSY∀X@AC9HA]K
KggCIr~∀~(~∃!C≥J@fZ\`@@@@@@@@@@@@@@@@@@@@@@&LZb\n8b@@@@@@@@@@@@@@@A KG∃[EKdlX@bdnn~∀_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@A)QJ↓'sgi∃Z@@@@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∃[K
QC]SM[fACIJAgKP@Ak`↓g↑Ai!ChAC8@A←a∃eCiS9N[gsMiKZA
←[[C9HAGC8AS]m=WJ@A1∪' A¬]H~∃
CkgJASh@↓iV@AMKh@AU`@Ai!JAK]YSe←]5K]h@↓gCmK⊂@AS\AiQJAMSY∀X ↓↓¬;#↔9αβS#∃π≠π[↔ h+↔;6KK?;n+;Q↓εKEβ'w3?/↔"↓β∂?w#K >D ↔
α∞ ↔∨≡\@π&Z∧∞FF* jVv∨M≥vw~∧
⊗rε≡Dαπ>
≤6BπM Vph.
&}≡\XBπ&tλFzπM Rε↔↑=⊗v/>4ε}2∞Mε*π>\'∨O>LVjPQ!PRα∧
FF*∧ WF∞>Dαπ>≥∀ε}2∧∞6∂6≥lrαπM Rε.nm↔ε}m\Vw"∧ FN6lZ'
α j&}j∧
⊗oεL]V.wL≡FN}d
Fxh-≥Wεf]\Vw&≤M⊗}rd∧∧Nr∞Mε*∧↑]G&N>4εNo
H -\9]_.M;{@∞M→<Y$
<h_$ ];XnM9{@ <;≠→,D≤x=LWA"C!.x=P∩H⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ#)ba∀εEεEλ⊂⊂⊂⊂λ⊂⊂∀9X{2P⊂→4πo) sav@∃`
↓β&C∃↓β≥+CK↔w!↓α∩M~A↓β,s['K}s7π≠ ↓β'9αβ¬↓↓∧∧fNfT∧εv∞\X ↓QHλλ∧∧→[se@9{↔&∩ih⊂4[⊂:42H⊂;wi~βifg↓ISeK
iWer8@AM←αy↓β'~β;?Q∧+[π3. S↔⊃p↓↓αSF)βOπ4¬⊗v8Q$ααα∧ wε/,≡FN}d F/∨N-wO~∞Mε*π⎇}&@=9Y`⊂_wx<P≠s⊂:4→P2w;~y7w6Yw:⊗⊂≤wP;t→w⊂:4→P9p{→P4yFB⊂⊂⊂⊂λ1wvx≠2z2P∪$ih⊂≤2z:i≠9P:7H&zv 4ics Command level.
All variable values(λ@A→SYJ@↓←EUK
ifX@↓CeeCd@AG←αsS↔;'→1↓↓ε ;⊃↓ε3W;∂&K?84R↓↓↓↓ε#↔≠'vKS'?w→↓#πv!β?SF+IβC⊗{C↔K&K↔M%∧ K∃β≡ [↔⊃bβ WQπ##∃β≤{;S↔w#Eβ?2↓βS#*βCWO@h)↓↓α↓β∪?>qβ3'∨#M!βNs∂3W&K;≥βπ∪↔['␈+Mβ[∞cWπMε{⊃β ␈+;⊃β6 K'π⊗c↔M1∧≠π;;⎇!↓β *βOπ[,!04)α↓↓↓β≡y↓βO∂3∃βOF{W3⊃αβ?;3Jβ ∃↓π+O↔⊃ε3K?5αβS/Aεc↔[↔bq↓↓"≡+∃βπg≠=↓β&C∃↓β≡+∂S'}qβ?8hQ↓↓↓αα∨π'vK;≥β∞s⊃α/.+C';8απ?;'∪?11ε∪↔3?:H4(4Ph)↓↓∧K9βSF)αB∩αiEAβNkC3↔n+;Sπ&K?;Mπ##↔K*β'Mβ
β≠W;∨#'?9ε≠π33.!βOW∨β↔;⊃Ph(4+∨+OC↔v!↓↓↓α↓↓↓↓α↓↓↓αe~V
Iβ↓βS=β⊃βπK?_4(∀R↓↓↓↓α↓↓βO/≠C↔;"βCWS~↓α2&≥↓β'9ε ↓βO& S∃β∨+∂!↓π##πQεKQβ∂∞q↓β *↓jB∩,jA∨↔"↓↓"&%→%β?⊂h)↓↓α↓αNN
2∃∨⊃α↓"α⊗~iEA%αβπ;⊃αβ3πS/⊃↓βK/≠SπK&+⊃9↓¬;#↔9αβS#∃αβOπ[.!↓β∂␈∪∃↓βNkπ∨∃εKL4)α↓↓↓β⊗+OSπ↔#↔⊃1αβ↔[↔↔KS#'v9β←'fa↓β *↓βS#*βOπ7*↓βπMαβ'Qβ> M↓β>C↔9↓π≠WOC.s∪↔⊃bβπ;⊂hQ↓↓↓αβ∂?;'∪?1β>K31β⊗+SWKrβ≠K?jβS#∃εK;[?≡ S'?rβ?→β∨+OC↔v!84(hQ↓↓↓α↓↓↓β∨+OC↔v!β7πJβ ∃β/≠↔⊃β∂!βπ;JβC?'w!β'9ε β∂?oβWSπ&K?91π;'S!αβS#∃π∪↔OS⊗K∂S'}p4)↓α↓↓βSF Qβ;z↓α%>zβ∪↔[N≠↔M↓ε{S#↔∩βS#πr↓βS#*βS↔KnK;π1εkπe↓ε∪∃β'r↓βWO*q↓α'2↓βπ9∧I><4R↓↓↓↓ε#↔['≡)β?SF+I↓β&Cπ9β&C∃↓β&+K7'v 1β'~↓β'9π+O∃1αβ¬β≠∞K17π∨!↓β∂␈∪K↔∂& 3∃ε+KK?⊂h)↓↓α↓β?∂∨+KM1εK;∪'≡ S';:βS#∃ε{≠≠↔v#';≥ε#↔['≡)#M%ph(4)α↓↓↓↓α↓α'9π##∃αM"M↓βNkC3↔n+;Sπ&K?91ε≠πK∃εKMβS∞[↔9↓π≠=βSF Qβπfa↓βO.∪OgO&+7Mβ≡ [↔⊂hQ↓↓↓αβ←'SBβOWOε+;⊃β7∪?5↓π##∃β≡ 7∃β6+KO'}q↓β?2α2&Nαβ←'3b↓βO#∂∪∃βSF)βCW⊗)↓βC∞;↔Mβ}04)↓α↓↓α2M~A9↓∧K9βπ&#'S'}q1↓β∞c1β'w3?∂π&K?;Mε{→↓β
βCπK&K∂W3∂⊃βOW↔≠gOS.i↓β←Nc1βOF K∀4R↓↓↓↓π##∃↓πβWK∃πβπ∨↔~↓βC↔∨+3'π∩βS=↓π##πQπ≠W OO≠S↔5r↓↓α∪.≠3πK∂#'?9ε{→↓β& S¬↓π#=β (h)↓↓α↓βC3∞≠↔⊃βNqβCW⊗)βCπ>+Mβ'~β∪↔O∨∪' ↔"β'9β
β3πS/⊃βO↔∨#'?9ph(4(hP4*∪.≠↔7 /⊃↓Y1β e]]α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠→5E9:qI↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓αε ∨∃↓~i]D4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3O≠AαK.3↔K↔v≠∃α7∞sWπ1α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4)↓α↓↓↓↓αα'9↓π##∃α$zBM5 ↓↓β'oβ3↔7.sSπSN{91β≡ K∃↓εKMβS∞[↔9↓π≠=βSF Q↓β∞c1↓αdJNCMε ;⊂4R↓↓↓↓π≠W OO≠S↔7~βOπ[.!β≠K}iα2&≥↓β←'faβO#∂∪∃βSF)βOπn)β#'>AβO↔>k↔;Qph(4)α↓↓↓↓α↓απ≠&+IβO/≠C↔;"β#πMπβK↔C∂∪↔⊃↓π##∃αdJNAβ≡{K∃7Nkπ∨∃ε3?Iβ'+7C'v91↓βO!βK↔'+K;LhQ↓↓↓αβ∂?;'∪?1β&yβS#*β?C↔⊗ S';:βOgO&+5βOzβS#π"β'Qβ≡ 9β *β∪W7ε+⊃84Ph)↓↓α↓↓↓↓∧K→βO/≠C↔;"β'M↓ε;'[↔rβπ9β∂∪∨W7.sQ1β&CπQ↓ε K∨Wn+;QβO→β↔cεc?∪↔~;↔⊃↓ε ;⊃β&C∀4)α↓↓↓β⊗+OW3&K;≥β≡CπKπ∨#↔I↓π≠SK'v9β'MαβCπO≡+⊃β ∞≠-↓β&yβS#*↓β?C/∪πS'v9βOg∨#↔5↓ε Mβ∧hQ↓↓↓αβ∂?7n ;⊃9α↓"O↔*β∂3'v)βπ;"β[π3⊗+Q9%α↓"?9∧JRMβ&C'MβO→β∪?v)β←'&Aβ¬↓αrZε2,)m↓β}p4)↓α↓↓αN J1βSFKMβ'~β∪?;*β←'SBβ¬αB$b>ε⊃r↓α?9¬">BMk AβSF)βπK?+7↔;"β'MβN;;?K.!9$4Ph)↓↓α↓↓↓↓¬##∃α≤
&1β6+KO'}qβWO/→βS#*↓βO↔≡{;⊃β∂∪∨W7.sQ1βN1βCK/≠↔;QbβπMβ
↓β≠'f)β;πn)84)α↓↓↓α&C∃β#N;!βO.;7↔;"β'Mβ'+7C↔"βW;∪/⊃βS#O→β;πn)9↓α&C∃β3␈9βO↔>k↔;Qπ≠#?Wf!βS#.qβ ∀hQ↓↓↓αβOπ[.!β←'&A↓αN
2∃1βv{QαN≤
Z∃9α↓αS#O→β'Mπ+O↔⊃αβS=β∨∪↔πS*βOW ∨KOS↔o→↓βSF Qβ∂∞p4)↓α↓↓βOF K∃β&C∃βO∞k∃β#N;!βO.;7↔;"β∂?;& ';'v9β∂?&)βOC.≠'≠'~βS=β&C∃βO.∪OgO&+584Ph)↓↓α↓↓↓↓∧≠?77}s3eβ}s∃β←Nc1β←⊗KS∃β
βO↔S/↓βK?/#';∃ε3?Iβ
βOW ∨KOS↔jβ3'/*βS#'≠P4(4R↓↓↓↓αCCK?>p4)↓α↓↓↓↓α↓↓↓↓G#↔KC⊗I$4)α↓↓↓↓α↓↓↓↓αCCK'v→↓∨?π#'?;≠Q$4)α↓↓↓↓α↓↓↓↓αq99β⊗+π⊃βNqβ?C&K?;Mαq984R↓↓↓↓α↓↓↓↓α↓#S↔↔βK%$hQ↓↓↓α↓↓↓↓α↓↓#C⊗K;
↓>c?π∪Ns≥$4R↓↓↓↓α↓↓↓↓α↓999εc?π⊃εK9β≠Nc↔Mβ}1β≠Wv≠S'?w→↓99ph)↓↓α↓↓↓↓α↓↓↓#>→$4)α↓↓↓↓α↓↓↓↓αCOOS∂#WMβ>≠S'7*↓A$4R↓↓↓↓α↓↓↓↓α↓#OW∨β↔;⊃Hh)↓↓α↓↓↓↓α↓↓↓#∨#πKQo##∃7∨+ Og∨#↔5$hQ↓↓↓α↓%$4Ph)↓↓α↓↓↓↓¬##∃β∨+ Og∨#↔5∨~↓β↔;6KK?;n+;QβO→β;?:↓βK↔∞#eβ≠␈⊃↓β∪.kC';:q↓απg#↔K;∂#'[↔gI04)α↓↓↓β}s∃β7N;#Qβ?∪'S∃αC?9αM"M$4Ph)↓↓α↓↓#O/≠C↔;"↓∨qj∧"V6A∧"N-j4z>∩&∪YαRM∧rNV
≥JM<4R↓↓↓↓βQ∩ε2bα∩>:*!<4)α↓↓↓βbH4(4R↓↓↓↓π;#'∂Bβ←'3bβ∪=β&C∃β∪.kAβ''≠↔3→αβπ;⊃πβK';"β¬β7/≠Oπ∨*β←#↔rβ∪?;*q↓α?r↓αNεLaβ?;(h)↓↓α↓β7'>CQβ←⊗KS∀4Ph(4(hP4*C∞;∃↓Mk9I↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠→5E9:qI↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓α∪↔≡+7 ↔∩↓Y1↓ I]\4P1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓αS#*αOgO&+5↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓)T"Jε~"Q(4(hP4(4R↓↓↓↓αCOWOε+;⊃↓?bNεZ*αNfMT2>=:≤
[p4R↓↓↓↓α↓↓↓↓α↓↓↓↓:B~>=¬~"Iα≥JM%$hP4)↓α↓↓αO.)βπ3≡yβS#*β[π3⊗+Qβ≠.s∂S'}q84(hP4)Es99M↓∧;π';Ns≥βπv!α/↔/β';≥∧≠?;S⊗{04(hP4)↓αα'9β&C∃α7.cS'∂~β'7Cf+7↔;& S'?raβ←#.qβ¬β≡ [↔⊃ε+;['⊗{;7↔w!β'Mπ∪↔OS∂∪S↔⊃εKQβ3}{/L4Vc'/∃αβπ9↓ε+KK?∩↓βS#∂!βK↔'+K;MαβS=↓π#?A↓εc↔[↔bq↓αSF)↓β≠␈∪7M↓εK9↓β&C∃↓β/∪K3'∨!βπK(h+↔[∞cWπS.!9↓↓¬##↔O*↓β≠?⊗kM↓β≡C?W3"↓β∪=π;#πS/3↔I↓εKM↓βv+∂↔O≡ Ke↓π#=↓β∨#πKQαβWAβ&C∀4+∨+ Og∨#↔59ααS#∃αβπK∨.k↔;S~βS=↓π##∃β≡{77πv!↓β←FK∂!βNs[?/.!↓βSF)βOW↔≠gOS.i↓β7∂Iβ ∀hS? S∞K;↔⊃π3'¬↓G≠SπS/→βπK:Iβ?IαCOSπ'+Mβ+≡a%84Ph)↓↓∧K9↓β&C∃↓α∧"A5Eα↓β'7εc↔7↔w#πS'}sM1↓π;#↔9αβ¬↓β≡ [↔⊃αβ↔;[O∪?;7.sQ↓βO→↓βK/≠SπK&+⊂4+/C↔∂W&K?9β≡{;S'w+↔M↓ε3K?5π##∃↓πβ?';"β←#↔⊗)↓βO/≠C↔;"β←πMαβ∂π3f+⊃9↓¬##∃↓εs↔cQε3?K4hS↔[πg+πS↔"βO#?.c⊃↓β&yβ←#∂#↔[↔∩β'M↓εs↔∂↔∨≠πKeπ#=βO& KQ↓π+AβSF)βOW↔≠gOS.i9↓↓αB'QβO_4+πg≠=βC␈≠O' f)βS=ε≠πWO*βS#∃π≠π7∃π∪↔SW⊗qβS=π#?Aβf+[↔1ε{9βO& KSWαβπMβNqβS#*α7W3&K∂L4VK7C3.k↔;S∂#'?9αβ e↓π+O';:β[π3⊗+Q↓βNsOS↔∞!↓β?2βOWOε+;⊃9J↓↓αSF)↓βπ⊗;W7↔w#M↓β}1βS#(h+∂?nkπ;⊃εc';∃π;#'∂Bβ';[}[↔⊃β&C∃βO.∪OgO&+5β7∂Iβ ∃ε{ SπNs↔⊃β6K¬↓#∨#πSWthe subsystem wants to hide the underlying Maclisp from the user, it has a
number of facilities available. By setting up its own user-interrupt handlers
it can handle any LISP errors which occur itself. In Newio implementations, it
can alter, augment, or abolish standard interrupt control characters. It can
replace the Maclisp interpretive interaction loop with its own by using (sstatus
toplevel) and (sstatus breaklevel). It can also provide a totally different
interaction loop by not returning control to the LISP top level when it is
started, but instead retaining control in its own functions which read and
respond to user input.
It is possible for a subsystem to retain the trappings of Maclisp but change
the way things read and print. Macro characters and the readtable can be used
to change the way input is parsed; alternatively, setq'ing the variable read
will redefine the system reader function (in the PDP-10 implementations). All
output by Maclisp (with the exception of character-string messages) is done
through the function prin1, and the subsystem may redefine this function. In
the Multics implementation one simply redefines it, but in the PDP-10
implementations the variable prin1 must be bound to the function which is to
substitute for prin1.
December 6, 1977 ∪3-1.7.2 Page 3-73
**DRAFT** Maclisp Reference Manual **DRAFT**
Some subsystems don't do any of this, but simply consist of standard Maclisp
augmented by some additional functions which may be used in forms typed in at
top level.
1.7.4 Purity
In the PDP-10 implementations, there are some facilities which allow
subsystems to put their non-changing data, function definitions, binary code,
etc. into pure pages. This decreases the load on memory by sharing pages
between multiple users of the same subsystem.
There are some extra storage spaces which are used to store pure (unchanging)
LISP objects. These are the pure list, pure fixnum, pure flonum, pure bignum,
and pure hunk spaces.
purcopy SUBR 1 arg
This function makes and returns a copy of its argument in pure storage.
This is primarily of use in the creation of large sharable systems like
MACSYMA. In implementations other than PDP-10 implementations with pure
spaces, purcopy simply returns its argument.
There are a number of features which control how binary code and
constants are purified when a compiled program is loaded into LISP.
bporg VARIABLE
The value of bporg should always be a fixnum, whose value is the address
of the first unused word of binary program space. This value generally
should not be altered by the user, but only examined. bporg is updated
whenever binary code is loaded by lap or fasload.
bpend VARIABLE
This variable should also always have a fixnum as its value; this
indicates the last available word of binary program space. This is updated
by many internal LISP routines, such as the garbage collector, the array
allocator, and lap and fasload.
Page 3-74 ∪3-1.7.3 December 6, 1977
**DRAFT** The System **DRAFT**
pagebporg SUBR no args
Causes the variable bporg to be adjusted upwards so as to lie on a page
boundary. This is principally useful on ITS in conjunction with the
function purify. pagebporg returns the new value of bporg.
getsp LSUBR 1 to 2 args
(getsp n flag) ensures that (- bpend bporg) is at least n, allocating
more memory if necessary. If flag is non-nil, then the memory added is
marked as being potentially purifiable by purify. If flag is omitted, the
value of pure is used. This is generally used by clever subsystems loaders
to expand binary program space quickly so that fasload will not require
several garbage collections to do the same thing. It can also be used by
programs which create and destroy many arrays. See also noret.
noret VARIABLE
Normally the garbage collector will return memory to the time-sharing
system if (- bpend bpOrg) is very large, but setting noret non-nil prevents
this. This is useful in conjunction with getsp.
purify SUBR 3 args
¬
The first two argumefts to purify should be fixnums, delimiting a Range
of memory within the LISP system. The third argumeft is a flag. If it Iq
nil, then the pages covered by the specified range od memory are made
impure, i.e. writable. If it is t, then the pages are made pure, i.e.
read-only and sharable. If it is bpore( then the pages are made pure, but
in addition some work is done to make sure that no UUO on those pages may
eveR be "clobbered". (See pure and puRclobrl) Dhis oPtion qhould always be
uSed iF the pages involved contain binary co@⊃JAY←¬IKHA rAYC@@A←d↓MCgY=CH\~(@@@@↓!eKg∃]iYr↓akeS→rAI←∃bA]←QQS]N↓S\Ai!JA)∨A&Zb`↓S[aY∃[KMi¬iS←\lAShA%bAS]QK]IK⊂~∀@@@Aae%[CeS1rAM←HAae←⊃kGS]≤AgsgQK[fA kSYhA←\A1∪' X↓gkGP↓CfA≠¬π'3≠∧XAS\AgkG AB~∀@@@A]CrAi!ChAaUeJ@AACOKf↓GC\A JAgQ¬eKH@↓EKio∃K\AkMKef\A qC5aYJTAiQJ↓M←YY=oS]N4∀@@@AMk]
iS←\↓[SOQPAEJAUgKHAQ↑Aae=IkGJ↓BAgQ¬eCEY∀AgsgQKZA←8A∪)&h~∀~∀4∀~∀~(~∃ K
K[EKH@lX@Drnn@@@@@@@@@@@@@@@@&LZb\n8h@@@@@@@@@@@@@@@@@@@@@A!¬OJ@f4nj~∀ **DRAFT** Maclisp Reference Manual **DRAFT**
(defun superdump ()
(setq lopage (pagebporg)) ;save low page address
(setq pure 3) ;specifies pure code
(setq lopage (+ lopage 6000)) ;allow for area 1
; (ITS page = 2000 words)
(fasload funny fasl) ;load up system
(fasload weird fasl)
(uread some lap)
...
(sstatus toplevel ;set up top level for system
'(top-handler))
(setq hipage (pagebporg)) ;save high page address
(purify lopage (1- hipage) 'bporg) ;purify pages
(suspend '|:pdump sys:ts super↑M|) ;tell ddt to dump
(terpri) ;stuff for system startup
(princ 'welcome/ to/ supersystem/!)
(terpri))
pure VARIABLE
This variable, initially nil, should be made non-nil by the user before
loading binary code which is to be made pure. It signals lap and fasload
to be circumspect about any UUO's in the code, because pure UUO's cannot be
clobbered to be PUSHJ's or JRST's. lap solves this problem by clobbering
the UUO immediately if the referenced function is already defined and is
itself a subr rather than an expr; otherwise the UUO is made permanently
unclobberable (i.e. CALL is converted to CALLF, etc.).
fasload is somewhat more clever: it too tries to clobber each UUO
immediately, but if it can't it puts the address of the UUO on a list
called purclobrl, which is checked at the end of each call to fasload, and
each UUO on the list is clobbered at that time, if the appropriate function
had been loaded by that call to fasload. If the function never does get
defined, then purify will also check purclobrl and convert each UUO to its
permanently unclobberable form.
If pure has a fixnum as its value, then fasload (but not lap) behaves
somewhat differently. pure should be the desired size in words of the
"uuolinks area"; this is rounded up to a whole number of pages. (If pure
is between 1 and 8, it is the number of pages rather than the number of
Page 3-76 ∪3-1.7.4 December 6, 1977
**DRAFT** The System **DRAFT
*
words.) Let the number of pages be n∞ First fasload callpε@Aa¬OKEa=eNXA¬]H~∀@@@AQQK\AIKgKeYKf@e8AaCO∃bA←LAEC]¬erAaI←OeC4AgaC
JXAk9YKgf↓BAae∃mS←kL@AGC1XAi↑4∀@@@AMCg1←CHA!CfAC1aKCIdAeKg∃amKH↓iQKZQR]J8AiQKdACeJ↓eKgKβ∪[↔⊃ε{;3e∧{;∂∃Jq↓αSG+L4)α↓↓↓β6 O3?∞!β#π~βSO=π≠↔SMε{⊂∩εd∞ε∞≡↑4απ&t
v␈⊗4∞vO&π4π>
∞=ε∞fD 6∞fD
FF*∧ fO↔>Dπ∞/AQ"αα∧∧αε∂,\∩β
$λ⊗v"∞Mε*π<X6}vD∞6/"∧∧&∂⊗\∀β∩∩d∧∧v←t
vF.lZf/∩ l↔≡f|≤BεF≡4π&@hλ≠
|9λ_!QHλλ∧∧_{∪l,Y<X,-→(∃*Ykλ∩.D→≠y.P77zλ860qYP4z⊂~w⊂:4→P1wr→P12t[3P67Xp2rελ⊂1:`4 rather
hashes it @¬]HAa1CGKf↓Sh@A%\ACe∃B@bA%HAShAoCf↓]←hAQQKeJ↓CYeK¬IrvA∧@AG←ArASf4∀@@@AaYC
KHAS8AiQJAgC[∀AeKY¬iSmJ↓a←gSQS←\A%\@ACIKB@dαq↓αSF+9βπr↓αb∞"β';O'∪W∂SN{84)α↓↓↓βε{';SNs≥βSz↓βS#*αVV=αβ'9β∂∪↔¬↓β β'Mπβ3π∂.!↓β'rβS#∃αβ ';∂∪eβ∂}#∃9↓αα←#↔rβπ30hQ↓↓↓αβ3/π&K;≥βF Mβ .+9β∪}s∃1β∂∪↔¬↓⊂β7πeε∪∃βC/∪'≠'.!1β -!βπK. ↓Eβn eβ;␈!84(hQ↓↓↓α↓↓↓αv{]β←F+9↓β↔+;;'v9βS#*β∂?∪*a↓βSF)αVVz;M↓βε{';S.!βS=ε∪e↓β&C∃αb≥!∨M↓εkπeβ⊗(4)↓α↓↓β∂f{ ↔⊗+⊃↓#&C∃αB%↓5EA∧b&NA¬*V=↓εCπ;∪f+Aβ'~β∂3↔6+Iβπ⊗{WQαD~Q%1αβCK?6K∪↔⊃bβ?_4R↓↓↓↓ε≠?WK≤)1βSF QβSF)β[πg+∃↓β}1β;?/+=β'~β;'1bβπ;⊃αβS#∃ε≠?∪∃π;'31π∪W9↓ε3πOS/⊃βS#(h)↓↓α↓βO↔≡{;⊃β&K7∃β∂∪?W; ↓β ↔≡ WO∃π##∃αD~Q∨Mπ;'31αβC?'w!βS=¬αVN"R;M9↓αα#/←/3↔I1εK_4)α↓↓↓↓G≠OSπ'+M↓β/+?3'v[M%βO→↓β∂∞c3↔⊃bβS#↔r↓βπK. ↓I↓εKMβ∂␈β'↔⊃αβ π∂Zβ';Sz↓βπK. ↓E0hQ↓↓↓αβ↔≠≠.≠S'[.ceβWv≠3? ⊗+K';:βπ31π##∃↓¬*V=∨~q↓αSFKMβπfc?←Mπ##∃↓ε≠π33.!β≠Wv≠S'?w_4)↓α↓↓βSzβ ∃β'∪π∂↔"βπ∨πNq1β≠␈⊃β↔c∞kC3∃bβ?Iβ⊗+∪↔≠Ns↔⊃β∂→β↔cπ⊃β∂?&)9↓↓∧sπSW⊗ 33ebβπ84R↓↓↓↓ε K↔¬εcπK∨*↓β↔;␈+∨!β&y↓β∂}sSπ'rβπ31αβS#∃¬*V=∨~↓βO#␈+3⊃β⊗)↓βK/≠↔K[.!m↓#∨#πSW_h)↓↓α↓βWW}c';/~I↓#Ew19%βNK↔3∪~β';≠␈∪7πSN{9βK.c↔[πw!βS=π##'Mr↓απMε βKWf)↓β?2βS#Wn⊃04)α↓↓↓β&C∃βπ⊗+¬β#≡{W3⊃ε∪∃↓↓∪↓∃β3∂∪∨↔Iπ##π9π##∃↓εsW7 /⊃β?→ε3W;∂&K?;Mε≠π33.!↓β JβS#∀hQ↓↓↓αβ3?π&+⊃↓β≡{∪∃↓FK;∂3.#';≥αα2&Nα↓β≠Wv≠S'?w→βOW≡A↓βπ~β↔GW∞a%9↓αα≠?IαβS#∃∧"⊗
5 4)↓α↓↓β[/∪O'?raβCW⊗)β7πJ↓β ∃π≠↔Qβ&y↓β¬εs↔∨π&K[∃β6 3W∃r↓↓βSF)β7π>s'SW&)β'MαβWO↔"βπL4R↓↓↓↓ε ?[*aβ←#Nc∃βSF)βO'>qβ∂?w#K?3~↓β←#N≠!βO.;7↔;"βS=βf{π⊃βNsS=↓Gβ?O'&K[∃↓βiβ3?8h)↓↓α↓βO↔>k↔;S~aβ;↔> S'[*↓uβ#N;!βO.;7↔;"I9↓α
β;↔∨∂#'[∃π3π3W*βπ3Oz↓β∂π/≠↔Mβ/+?3'v[L4)α↓↓↓β∂∪↔¬↓
↓βS=ε;=↓βNqβS#*β3?]αβO↔∨n+;Q1ε ;⊃↓ε K↔¬β⊃β'9αβS#∃εC'∨!αβO↔∨n+;Q9αα≠?HhQ↓↓↓αβ∂?7ε S' Nc'Sebβ¬β;.;πS'6)β[πg+∃β7. ;M↓π##∃β≡ 7∃β∂→β¬βε{O'SO3∃β[∞cW∃↓π#=βSF(4)↓α↓↓α&%→β'7εc↔7↔w#πS'}q84(hP4+C/∪∂3?↔∪1↓↓α↓↓↓↓α↓↓αZ
∩&ε
d(4(4R↓↓↓↓α↓↓αW≡+⊃β J↓β≠π≡c?π⊃π#=β/.+A↓β'∪π∂-ε{→αV,y∨M↓π;#'∂BβπK∃πβ?S↔w#'π3gI↓β /!β;? h)↓↓α↓β'7n+∪'π&+3eβ≡c? /∪π 3*p4(4Ph)+C/∪∃↓↓α↓↓↓↓α↓↓↓↓α↓αZε∀Jε
2(h(4)α↓↓↓↓α↓αS#O→↓β[∂∪'π f)↓β∂}sSK?g→↓βπ/#?7π&K
↓βπ+K'≠N≠πS'}q↓β?2↓αM7/CCK↔∨≠'?;~βπ;⊂hQ↓↓↓αβπS?nK
βONk ?3~q↓α'2β'QβO→βO↔"β;?9ns'1↓G##∃βNs'S'∞aβ[πg+∃β'~β;'1Ja↓βSF+9βSF(4)↓α↓↓β≠}c3?←Ns≥↓β∂∪∃βCf ∂↔⊃αβ'9βπ+K∃↓π≠S?K∞;∃βOε ∂↔Mαβ';O&+π⊃β}1↓βK.;W3π∩βOS?⊗ ∨∀4R↓↓↓↓π≠Cπ∂/→i↓βεsπ7↔~β?→β∂#?7'~↓βOgn∪?3MZβ3'O"aβ≠'FsW51ε33?;.i1β N;;W5b↓βπ;"β#W;Xh(4(hR∪↔∂.k ↔Iβ11↓EK9]↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓MMk 9]9"↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓αCπ>)↓M5;84( **DRAFT** Maclisp Reference Manual **DRAFT**
constants used by code loaded with fasload; properties whose indicators are
in the list which is the value of the variable putprop (initially subr,
fsubr, and lsubr). In the SAIL implementation, if *pure is a fixnum, it
should be an estimate of the total number of pure data structures needed,
including all files previously loaded and the initial LISP system pure data
structures (currently about 6000. words). This causes purcopy to use the
high segment for pure data. Making the estimate in *pure too large merely
wastes space in the high segment; making it too small causes purcopy to
make copies in the low segment when it runs out of room in the high
segment. This whole feature only works if pure iS a negative fixnum.
putprop VARIABLE
If the value of *pure is non-nil And the third argument to the putprop
function is in the list od indicators which is the value of the variable
putprop, then the second argumeft is passed through purcopy to purify the
structure. Furthermore, the two celhs od the property list are cons'ed
from pure list space* Since impure ceLls must precede pure cells in the
property lisT, putprop may ngtput a new property at the fp¬W]hAWLAQQJ
∀@@@AAeWaKIirAY%chAS8AiQSβ→β∂π≤)0$(hQ↓↓↓α↓↓↓α&C∃βC-#CK∨α↓βπ≠ ∧πε.↑
&␈α jVv∨M→vw~∧ 6v␈tλ⊗⊗␈↑@ππ∂-_fN.D∧ππ⊗|∧⊂∩\8∧q @1Sgif8~∀@@@AβL↓]KGKMcCeR0@AiQ∃rAoS1X@AGα{Ceβ&C∃↓β¬∪?C↔↔#eβ3M≠Q↓↓F∪WQβv{Q↓β&C∃βC⊗{C↔K&K↔L4R↓↓↓↓∧εFF.↑8VgY<j$
9]≠d
Xπw-pp eJ↓ci←E¬K@∃β≤¬rπε ≡BεODλλl≥H_Y$
αp∂did¬SKHαq↓αSFK@~ε≤4π'↔\QPBα∧∧απ⊗\|↔ε&LZ7
ε|dπ&FT
f∞g\Tε}∩∧¬'π<Y+D∧∀Y0l≥≠λ⊂-N{h⊂~~0z⊂ $e`
ae=`AC]⊂@AIK→k\AkMJ~)α↓↓↓β∧εW'π-x ¬@∧¬∀~(~∀4Ph ⊂@ ¬εEβE
λ∧⊂∀!Q hPβ"C!∧¬∀~(~∃!C≥J@fZβ9a↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓≠→5E9αqc"α∧∧ααα∧∧ααα∧∧ααα∧∧α∧→8p∩[q2y 4∧X@BβIP≠_Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hS∃gαα∧]≡6≡.ML⊗v.}↑2∧7]l7&N⎇n0hPQ!PPh&∃cBs∀∧¬&FT
7&∂N↑2∧7]l7&N⎇n0hPQ!PW∨L≡G/~∧∧ααα∧∧ααα∧∧α∧5:X%⊂h!Q"αα∧∧ααα
Mε*α∞>F∂'↑4π∨ε\=⊗∞b∧ f␈⊗T
↔~α∞↑6."∞Mrαε|↑Bπ& Tαπ6≥NV*ε|dαπ6≡-⊗␈/4∞7O∨L]PhR∧∧ααπ ≡&∞n↑LW↔~d∧α∧ON4αε6≡.7"α ≡&?.\]g"b∧
f␈"∧ W6∞N\↔&.EDαεO4∧ε∞r∧ ↔&}]≤2π∨≥\&}`Q$ααα∧
⊗v&≤<↔&Nltπ>F≤=αε}d
↔'~
\⊗wJ∧ g.v>M⊗}w4∞7&∂N↑2π≡
}Vf"∞ W⊗6}-Rrα
Mε*α∞↑6*ε|aPRα∧∧αε∞LM↔&N⎇l⊗bα ≡&?.\]g'~∧ F/ε]lG~α
⎇bαπ⎇ ↔"α∞Mε*α m↔↔∨D∧ε∂⊗}]V.wD∧εO~d∧α¬& ↑6(h$∧ααα ≡&?.\]g'~
\↔Jε}$εn∂∀
f␈" ,Rε/l≥G.∂L\BbεL↑ε.vM≥f:ε⎇dπ&FT fO↔>Dε∂⊗}]V.wEdα∧NaQ"αα∧∧ε≡/.L⊗Nr∧ ⊗&&≡M⊗}v≥Dε∂⊗}]V.wN4αε∂,Tε}n≡NF."D∧ε
εL\f∂.NDαπ6≥NV*α
≡2π∨↑∞εfN\E@hR∧∧ααε≤|⊗Nr∧ F/ε]lFNvt∧ε}r∧∞vF∂D∧π&FT∧ε6O.>Bαε≡,w.n]nBαε≡5bαα
Mε*α∞l↔⊗N}↑2π∨L≡G/_Q$ααα∧ g.v>M⊗}w4 ↔⊗*
M↔∨&\Dε⊗.M}rph!Q'∨∨L≡G/~∧∧ααα∧∧ααα∧∧∧5≥X* hPQ$ααα∧∧αα¬M Rπ∨>L↔'/4∧π∨ε\=⊗∞b mw⊗j∧
↔~π↑<V"πMtαπ≡↑Dπ&FT∧π6∞N\Rε}d∧π6∂-≥w/~∞?↔∨&]QPRα∧∧απε≡,⊗n/L↑'~r∧ ↔'~ ≡&?.\]g'~ ≡&*π=≥VNf≡$π&z∞Mε␈≡T
v"π>L↔'/5aPPh*Mε/≡T ↔⊗*∞Mε*πM
⊗v?4∞FF∂D∂⊗␈* <⊗rεMtπ>OM∧π∨&≡NW~ε≥lBπ∨>L↔'/7!PPh*:D
%Z4∧5,h:DL|j4∧4⎇$ ∩|xQ!PW&≤.6OVT∧ααG>L↔'/4∧π&∞.=↔V*∀∞&/'↑-g~α∞Mε*εn]V⊗/$∧ε}2 =ε∂⊗≤>F/∩∧∞ε␈≡≡M⊗}w4 ↔∨∨]\V h$∧ααα∧∧ααα ,W'>\]bαπL≤"π∨M}π~b∧∞vFN=∧ε&/ ]f'~∧
vrπM Rαε≥↑εf.\]g&∂M≥vrr∧λ7/↔,]g&g⊃Q"αα∧∧ααα∧∧π&F≡4αεO4∧βBα
≥bαπM R¬∧J¬S α∧
⊗oεL]V.wL≡FN}d∧ε∞vD∧β αd∧εNr∧∞FF* ↑Vg&≤>0hR∧∧ααα∧∧ααε≥↑εf.\]g&∂M≥vrpQ!PVv↑⎇FNvT∧ααG>L↔'/4
f/>M≥f*J∧∞&/'↑-g~ε∀∧ε6O
nVjπ⎇
⊗≡B∧
↔~πM Rαε≡<6NJ =v&*∧ f␈∩∞Mε(h$∧ααα∧∧ααα =ε∂⊗≤>F/∩∞⎇εN≡∧
V∂⊗>4απ& Tε.vD
v2ε∀∧εfNlTε}2
≥gπ/Edα∧6}$αε/ ≥WεfUDε}vQQ"αα∧∧ααα∧∧εnN⎇∞Bπ≡∨∀αCj¬∞6/'∀ 6Bα∞O⊗JJ∀¬π∨&≡NW~εl↑vfNlU∩Jαdλ7/⊗\]g&g∀∞FFO4∧εO~ε⊗PhR∧∧ααα∧∧ααα
|7&∞E∀εNr∧∞FF*
λEαk⊗∧αεN↑
F.n]nF∂&≥⎇bε∞lDβ ∩∧¬ε}∨L≥BJε≥dαπ& T∧o.NM⊗∨_Q$ααα∧∧ααα∧
⊗oεL]V.wL≡FN}eaPPh,=ε∂⊗]|F*α¬∞7&∂N↑2ε≡ ≡&n}LTε2J∞,W'/-n2π& Tπ6∞N\Rε}d∞FF* =ε∂⊗≤>F/∩]]v&*∞>vO&=∧ε6␈!Q"αα∧∧ααα∧∧π&FT fNfT brα ≤bε2
≡2π"
}"ε}]≡G&.D∞FF*∞l⊗g.T
v2πO≥rαGM Rε&\l↔.gD
w/'∞↑@hR∧∧ααα∧∧ααπL↑&nNl≥BJε≡4ε∂∨>]V."d∧∧N2∧∞FF* =ε∂⊗≤>F/∩]]v&*∞>vO&=∧εO~∞DααGM Rεv}-V∞`Q$ααα∧∧ααα∧ 6∂≡T f␈∩∞Mε*πL↑&nNl≥BJε}↑Gπ/D
↔~α∞<Vw"∞Mrπ& Tε&/m≤6*ε≡4π≡}⎇dε∂~∧
↔"ε≡1PPh!Q$&.<]V⊗/$εbbβ↔⊗s:α∧∧ααα∧∧ααα∧∧ααα∧∧αα↓65S
s∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬ε≤|Rβ~Vw⊂hPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hR∧∧ααα∧∧ααε|]f/⊗≡LV"r∧ ⊗2πM Rπ∨⎇≡F≡B
≡2εv≥DαG& Tεv␈-\⊗bε<≡6*εm}"ε6≥LW~ε}Mε/∩∞Mε∞pQ$ααα∧∧ααα∧∞FF*∧∞F/⊗]≥f∞b∀
w/'∞↑Bαε≡4αεF]LBπ.nM⊗bα ∀αεv↑⎇FNvT
↔~α∞O↔ε.EDαε∞d W↔⊗}!PRα∧∧ααα∧∧αε}<>W↔~D∧εNw∞↑BεO4∧π⊗/≡\W∨&\EBαε}$π&FT∧ε↔.llW∩ε,\6}n↑4αε7]MBrα∧¬∧Nr∞Mε(h$∧ααα∧∧ααα ↑Vg&≤>2εN↑
F.n]nF∂&≥⎇bbπ≥}Rαε<≥bε∞N=rε≡≡↑6*πM Rαε.\f6/$∞Fzε,Tαπ≡]nBε↔⊃Q"αα∧∧ααα∧∧π/≡≥lrπ& Tε6␈,<Rn␈↑Nπ/"∧ g.v>M⊗}re∀¬&F≡4ππ⊗}m⊗&/4∧εNv>,V∂≡\Dε.6m≤6N.l?⊂hR∧∧ααα∧∧ααε≡Dπ&FT 6␈∨D
v2εm}BεN]\V&N≡LVgJ∞<V.Nltε∞fD
w/'∞↑BεNd∞6}nT 6∂≡↑5`hPQ$ααα∧∧ααα∧¬π∨∨L≡G/~ =ε∂⊗]|F*π∧ bJπ<↑G~πM Rε≡ ≡&∞∨L↑"nn|LRπ∨⎇≡F≡B
|bπ& Tε6NLTε2α aPRα∧∧ααα∧∧αεn∨∀αε⊗T∧π"α
}"ε}]≡G&.D∧π&z∧∞6N>m≤gJα∞Mε*ε}↑Gπ/D∧π&/-]⊗v∞D∧εNr∧∞FF*∞O⊗xh$∧ααα∧∧ααα∞l↔⊗N≤-F*J∧∞Fzπ¬Dαπ>
≤6Bα
\↔Jε,Tαεv≥Dε␈∩∧∞Brα∧∂αε∞lDαε2∧ ↔⊗* ↑f∞g\≡F."aQ"αα∧∧ααα∧∧∧∨/.,Vw&O∀εNr∞Mε*¬λJαk ∧
⊗oεL]V.wL≡FN}d∧εO"
≡2εv}Dπε␈>=⊗⊗fT∞Fzα∞<W"πM PhR∧∧ααα∧∧ααε= ↔⊗∞>LW∩n]|F*π>⎇↔&≡π4αε}lTεo/>Dαπ∨ \6N7∀
↔"α
≥fO&≤≥FgJ∞Mrαε} Vrr∧
6.(Q$ααα∧∧ααα∧ ⊗g≡t¬π∨&≡NW~εM≥fn}LU∩ε∞lDαG∨L≡G/~ m⊗f.tus linmo@⊃JRAe∃CAf@↓iQJ@ YS]J↓[←IJλ@AC]⊂@QggQCikf↓YSM[=IJ@A`RAgKQb~∀@@@@@@@Ai!J@EY%]J@A5←IJD↓iV@A`@QhA=`@A]%X\RAQQKgJAMk]
iS←]LAaCW∀@AC\↓←aiS=]CH~(@@@@@@@@↓Kqie∧ACeOU[K@;"aβ←#L≠!β'~βS#∃∧3'3∃¬;#?O*β3'≠*β7?∪*β'M↓ε∪↔'≠8∧ε&O<8
.yrr.
ThipεAIK→CkIiLAi↑@↓iQJAYCYkJ↓←DAieR@@QQQJAI∃ICkYβ!β';π+Q↓β&+K .≥l⊗bJd∧∧NpQ$ααα∧∧ααα∧ ⊗wJ 8λ.≤+λ∃
<h⊃M≥→(∪.↑⎇λλ ,(_ ⊂≥2y6t[0p .A∪LAM←[J@↓S[aYα+7.β]_.M;{\d∞~→#!$λλλ∧∧λλλ∧∧[~;LT≠;p∩→Q⊂6p↑P77jλ12P!Z0s3rY↔⊂⊂⊂∩pε the "lIne mode" IpεAhXAkgKHAS]aUh~)α↓↓↓↓α↓↓↓βO→β W4∧f/⊗\@π/α ⊂εfNlTε∂" ⊂π&N\Tε⊗.mz&*ε,Y⊗v:∞8Vw"∞Mr∧d~:αrα
Mε*ε≥nπ/"QQ"αα∧∧ααα∧∧ε.&≡M⊗v: =vw6]nFN}n4αε}d∞FF*∧
ε␈∨D wε/,≡FNvt∞7O∨L]Rαε≡,Rπ/<XBrα∧ ⊗2πM PhR∧∧ααα∧∧ααα-M⊗v*∧
V}&T$εO~∧
fNbD DM≥∧∧π∞.↑4αε.≤=αε≡ ≡&∞∨LZ"αε≡4εO"∧
↔4λ≥≡. 9λ_-lβ"H∧∧λλλ∧∧λλ_.∞≠~9.∀λ~=∞4≠⎇{D∧~;\∞↑λ→1
≡~;Yd∧_{sNl;]~-⎇\kH∧
~~<d∧≠;y Tλ_x-d≤≤[nm9→#!$λλλ∧∧λλλ∧
;\≥.D→X8m≥~=~,↑h≠;n,(≤⎇-≡→9∧∞≠h∪ ~tλ_-lλ≤≠n≡z8[∂∀_Y=∞L<Hλ
;Y≠
≥Yh≠la"Hλ∧∧λλλ∧∧λ≥~ T≥→<M];X;¬Dλ~9D
=λ∩.4λ_(∞O<→(∧∞~_=∧ ∩4t∧
{[⎇n4λ_( ↑Y8=∧∧→→8-D_8[n↑ C"D∧λλλ∧∧λλλ
⎇y=L↑Kλ~.D≥<y.∀λ≠;n,(≠8,=~;Y$∞Y<{n↑Xy<edλ∩=∧∧~<h∞
||z,-→(→M}Hλ_$∞<y<AQHλλ∧∧λλλ∧∧≤≤[l}X;(∞Mh≥_-<(→~.,8⎇λ ={]≤M⎇λ≠yD∞~→(∞L<[:-l;λ≥m ;H≥
(λ[
≥Y(≠-|→(H
≡c"B$∧≠Z;π4~≠⎇l↑Y<K∧∞~~<d
8>(∞,<=2.,(~{M}{→9 |(≠yD∞~→(¬∞|⎇_.N<h≥∞O*+H∧
~→#!!(λ∪.]≥~8n4~;<
L;9;NL=~;md_;≥l∨<h≠n <X= ↑h≥z.Mλ_(∧-~;Y$
;y→$$≠yH∞EHλ∀l\#"B$∧_;≤mt≥~→$¬≤|⎇ ≡≥<h∞N≡<xl≥J(→N]X⎇~-⎇H_Y-M⎇kH ≥H≥~ T∀p2)D~;<
L;9;NL=~;meβ"B$∧≥~→$ →9X.]≥λ≤l↑≥~;Lt~<h¬∞|⎇_.N<h≠
≥[;y T≥
+AQC"JE%JJTh→3⊃*E%JJC!!"]≥∂≥;]λ∧∧λ
≤n>_=≥.4≥≥≡-≥]λ_m <Hλ n;Xh m;→*$∞≥<[N4λ≠{D (≥≥∂∀λ~;NL<\].∞λ_z ≡X8⎇ ↑KC"D∧λλλ∧∧λλλ
⎇→;H∧∞~→( =_<X,>→<H∧ z_<D
<hλ∞O<→9∧
{Hλ∞M→(~-n≥=λ∧∞≥≡( m;→+∧∧≥~→$ ∩4t↓QHλλ∧∧λλλ∧∧≤≤[l}X;(∞⎇;≠λ ,(~;NL<\].∞→9λ ≥Yλλ∞M→(→N]X⎇~-⎇H→]-lh≥z-Mλ_Y$∧_<≤
M99λ∞Mc"H∧∧λλλ∧∧λλ≥∞⎇h_<L};9;NNh ( m;→( ≥Yλ_m <KH∧∧∩9H m;→(
≡h≠{-≡≥→9¬D≥~→$∞X;≥,Tλ≠yD∞≡:#!$λλλ∧∧λλλ∧¬≥~→$∧→→9L≡;≥λ∧
;\≥.D→Z; U(λ~.4λ_<n>;99¬dλλ∃
(_z ≡Hλ≠,∨(λ_LTλ→:.M→<H ⊃"Hλ∧∧λλλ∧∧λ_z ≡X8⎇ ↑H≠xM,8⎇λ∧
|H_$∧→Z>
n;(
≡xz:$∧_{y U+Hλλ≥↑(λ
|H≥~ Tλ ,G¬H_<l=:#"D∧λλλ∧∧λλλ =_<X,>→<\d
8>( ,(≥<l\ Hλ
M→(→N]Xh≠,∨(_Y$ :=~ ↑H_;D
|Y~-l<↑( n;X⎇
≥{X;↓QHλλ∧∧λλλ∧∧→[|MTλ≠|D (λ→M∨≠];%Dλ≥z
≤zλ≠,\;\h∧∞~→(∧ →9X.]≥λ≤o≡⎇→;$∧_8⎇
≥{Hλ m|H≥
#"H∧∧λλλ∧∧λλ_m <X8nL<H≥m≡~λ≥
=λ_.<z:(∞l;≥9%dλ⊃[n$~;\nL;Xy$ (→]-lh≠yDεhλ≠,\;\h∞≡:=β!$λλλ∧∧λλλ∧ X8zd∞≠h≥
(≥≠n∧≠→=L]λ≠yD∧∪∩4j∧
_{mn≤[{¬Xj+H∧ 9H→N]Xh~.4≠Z;¬Dλ≥~ T_z_.!"Hλ∧∧λλλ∧∧λ~<d
89→$
[{K-≥]→<N.<≥~-lkHλλ≥≠λ≥
∞Y9( ≡Y⎇;,]]≤h ≡Y(→.l;≥8.L9 C!!"T_,|( k'ελλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∧f5,+N¬f(λλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧⊃→8l]8Y<DεKλ '⊗mc"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧
~→(
?<⎇→-Tλλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
JQ
(1U
E!"C"AQHλλ∧∧λλλ∧∧∩;H∞M→(∩*Jh~;.
→;9-n_=~-⎇Kλ~.D≠8>$ Y(≠L\y<|l≡↑(≥
t≥<y$¬≤|⎇ ≡≥<h∞N≡*(∞Mc"H∧∧λλλ∧∧λλ~-l[|[$ 5∀h ≤[⎇=∧
[{K.>_;Y ≡Yλ~-n→<\N↑≥λ_m <X8nL<\kAQC"H∧∧λλλ∧∧λλ∩-d∀⊃∀¬V,λλ
≥<≠→-\;]_.M;{\d∞z~8m∧≤⎇<∞
|]λ∧ Z>≠N](≥≥∂∀~;\∞↑λλ≠-|→(
]|Y#!$λλλ∧∧λλλ∧∞~_;Dε,N D z_<L≤⎇→<N5+λ≥
;H≥m ;H_-d~;] ↑\]<∞D≠xxn↑\h≥
(λ_m <X8nL<H~.1"Hλ∧∧λλλ∧∧λ→[mL→9λ∧ ≠⎇{D∧≥≠h∧εhλ_M≡≤hλ ,9[|LTλ≤y-L8⎇~-lhλ_-dλ~;NL<\].∞λλ→N]X⎇~-⎇KC"D∧λλλ∧∧λλλ
⎇y=L↑Kλ≥
(≥;Lm{→→,Dλ_z ≡X8⎇ ↑H~<d∞_<|l\λλ_.4≥~→$∞y8{mlλλ_.,⎇;9-nλ≥≠aQHλλ∧∧λλλ∧∧≥~→$
;]→..]<≥∧ ];XnM;{K∧∞{hλ∞M_=λ∞M→(→N]X⎇~-⎇H_x-d→Z;∞L<Hλ
}=λ≥-nx;] \β"H∧∧λλλ∧∧λλ_m <X8nL<\kD∧∩9H ∀→Z>
n;(~.4≥<y,D→[|D∞~→( n;X⎇
≥{Kλ∞M→;H∞M→(→M∨≠];$
8>#!$λλλ∧∧λλλ∧∞|→8m≤↑(≤L↑=:<L\λ≠|D [|XM≤→→;D∞⎇<≤L∃8<xm≥(_Z.Nh_<d [{≠
}|nH∧ 9→~-lh_Z.A"Hλ∧∧λλλ∧∧λ≠H∞Mh≥~ T→Z>
n;(≤L↑=:<L↑h≥~ Tλ_Z.Eλ_;LD_9→
≥Yh
Nzλ≠Dε. J$∧→[|L-9≤h
≡ C"D∧λλλ∧∧λλλλm|H→/ ;<≠ Uλ~;D∧≥~→$ 5∀h
≥<≠→-\;]_.M;{H∧∞<z;Lt
εε Lεt
≠xnL;
(∧ <h_!QHλλ∧∧λλλ∧∧→];L>~;{D∧_;≠
}|hλλ9sU∀Iy 1h∧∞≠hλ∞ <Y[n-(λ_$∧≤=:.Eλλ_N↑λλ≠M}λλ≥
(λ\
∀C"H∧∧λλλ∧∧λλ_m <X8nL<H∪ldλ⊂sij∀Ss¬Y11⊂%Xkλ∀m≥Xy(ε& λλ∞,<=2.,<h≥
(⊂sij∀Ss∧∧_Z=∧ ;Yβ!$λλλ∧∧λλλ∧ε εε ∧ [|XM≤≤h≥
(∪1*H(_Z.EC"C!$λλλ∧∧λλλ∧λ>_;.
→.H∧ (λ≤nL;Y_.,λλ≤n\\}<nL;(_m⎇]Y3NM;{H∧
<hλ∞Mhλ≥.<(λ↔Kd
_smn≤[{¬Q"Hλ∧∧λλλ∧∧λλλ∧∧λ≥< ≡\[⎇eDλ_<l=:(λεεmJ(∧ <h_$∧≤=:.Dλ_z ≡X8⎇ ↑Hλ≥m
8zλ∧∞Y<⎇ ≡]≤h∞M→#"D∧λλλ∧∧λλλ∧∧λλλ∞>8\}.>→;+AQC"H∧∧λλλ∧∧λλλ∧∧
≤|nL=≥<d∞≥≡:-nλ mAQHλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
n;X⎇
≥{H
L;8Y ∀
→H 5#"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
∞>⎇_=∞↑h≥≠n
→=Y-D j≤L↑⎇_<NE<⎇8N?<⎇→-U*#"D∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ¬ ≠h≠M≥λ
}H
∂$¬≠~<nL;H→E∀
#!$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
πT
≥≡-∀→J(ε6J**%⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ
↔Lu***!QHλλ∧∧λλλ∧∧λλλ¬ →9U-d≤Y<nL<] .>8\}.>→;(¬¬#"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
∞<=≤( ↑\[~.>λ≠Z-E#"H∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλ
∞>⎇_=∞↑h≥≠n
→=Y-D≠Z;¬⊃"Hλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ
≠M⎇;]→..]<≥∧
Z;
!QHλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧
~;M≡~8;
∨Y+=
+={n-→
#!$λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧¬→;] ↑K<⎇,.}<⎇ ]**#!!"Hλ∧∧λλλ∧∧λ
≤nL=≥<d∞≥≡:-nλ_z ≡H→Z-L*(≤L↑≥<[N4→];L5λ≥~ T~;] ↑\]<∞D→];L>~;{D [|H∞M→#"D∧λλλ∧∧λλλ =_<X,>→<H =_<H
⎇H≥~ T≥≥≡$ Z;→%dλ→Z-L(≠8/∀_Y(
⎇:=≥ \ Hλ ≡λλ→ \X=;∞Nh≥≠aQHλλ∧∧λλλ∧∧≥ C!!"]≥∂≤{{\d∧λ
≤n>_=≥.4≥≥≡,={\h∞N≡,(∞N≡,J$ Z;Y∞4λ≥≥mt≥≥≡$ Z;→.4~;]
t_(λ ={\{mL+Hλ ⎇Y#"D∧λλλ∧∧λλλ∞=≠⎇; D_Y( ≥H~;N∞=λ≥∞O(_;LDλ≥~ T≠⎇~ ↑H_;D
⎇=≤∞↑λ≥≥∂∃Hλ∩,d≥≥≡&∀λ≠|D∞≥≡,AQHλλ∧∧λλλ∧∧~<h∞Eλλ~.D≥z;
D_Y(∧∞_:y-d_<h∞M→(λ ≡≤≤[n∞Z8= T→~<L\⎇~;md≠yH∧∞~→( L9X=-Nβ"H∧∧λλλ∧∧λλ≥ ↑[:;L≥λ
→ ↑→<[-≥Y9λ /(≥~ T≥X<M≤8[→.4≥≡:$ ;Yλ∞O;j+D∧∃~→$∧_Z;LM;Yh
≥]≠c!$λλλ∧∧λλλ∧ (_{mn{{→$∧~<h ,<z8l≥≠≡(∧∞<y9∧ [|H∞∞<\≠n<<hλ
|H→8m
z;Yedλλ∩-d_9→
≡~;{EA"C"AQQ→8l]8Y<DεKλ '⊗mhλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ∧leV+N F∀λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λλλ∧∧λ∀_,|( k'ε#"@↓EJQ∀H_U
JD∧λλλ∧∧λλλ∧∧λλλ∧∧λλ∪,≤{~4n∧∀Y9L↑Y;XlT⊂εpw≥pr⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂
*DRAFT(T~∀~(~∀@@@@@@@AS]QKeekββQ↓β≤CπKπ≥#↔KMπ#gC↔ ∧αε}d ⊗rα
≥gπ∂D
G'J∧λfNfT∞6F␈]HBαε≤hf.∨D∞FF(Q$ααα∧∧ααα∧
w/'∞↑Bε}d
↔'~ 9wπ⊗↑>ε}vM≥f:ε}↑Gπ/D
G'J h
-L+λ≠M}λ≠{D∞{{9$
⎇~→.$≥≥≡%a"C"D∧λλλ∧∧λλλ ≤β⊂7w→P0q3]vrw:λ4yP0H::<P_w2⊂:~2P7j~2y⊂$\β niL, a tpycons relationship
involving that tty will be broken.
To put ech screen, distinct from output,
(sstatus ttycons t
(open 'tty: '(echo out tty)))
which conses tty input with a new tty output channel which is set to
go to the echo area at the bottom of the screen.
(status ttycons tty1) returns the other tty file which is bound into a
console with tty1, or nil if there is none.
filemode (status filemode file) => (open-mode-list . internal-cruft). open-
mode-list is a suitable second argument for the open function.
internal-cruft is a list of implementation-dependent information which
may sometimes be needed by special programs.
The following symbols may appear in internal-cruft. (These are the
standardized ones; additional symbols may appear at the discretion of
the implementation.)
cursorpos This file (an output tty) has the ability to position
its cursor anywhere on the screen.
filepos The filepos function can be used to access randomly
within the file.
rubout This file (an output tty) has selective erase
capability. (cursorpos 'x) will work.
sail This file (an output tty) has the so-called SAIL
character set. This is an extension of ascii which is
related to but not necessarily identical to the actual
character set used at SAIL.
If file is a closed file object, (status filemode) merely returns nil
instead of giving an error.
Page 3-82 ∪3-1.8.1 December 6, 1977
**DRAFT** The System **DRAFT**
ttyscan (sstatus ttyscan func file) allows the user to supply a function which
performs initial processing of terminal input. func is a functional
form, and file must be a tty input file. If it is omitted, the value
of tyi (the default input terminal) is assumed. Both arguments are
evaluated.
When LISP wants to take input from file, it first calls the prescan
function, which is supposed to gobble down a complete unit of input
(for instance an S-expression) and return a list of characters. The
prescanner supplied automatically by LISP when a tty input file is
first opened counts parentheses and does fancy rubout processing on
display terminals. It also implements the CTRL/k, CTRL/l, and CTRL/u
characters (as appropriate to the implementation) which allow the
complete input to be redisplayed or cancelled, and takes care of
force-feed characters. A user-written prescanner might provide
additional features such as super-parentheses, name recognition and
completion, or fancy editing.
The prescan function func is applied to three arguments: the file, the
name of the input function on whose behalf it is acting (read, readch,
or readline), and a fixnum which, in the case of read, is the count of
the number of unmatched left-parentheses. It is supposed to return a
list of fixnums, which represent characters. The prescan function
should read the input with tyi, since it and tyipeek are the only
input functions which doesn't call the prescan.
Ib the pre-scan function returns nil, an eof condition occurs for the
input file. This is the standard way to signal over-rubout.
There is a function called rubout to assist the pre-scanner in
processing rubouts. It is described on page .
It is a good idea for the prescan function to lambda-bind echofiles to
nil so that characters do not appear in the echo files twice, and so
that the echo files reflect the "clean" input after rubout processing.
The system-supplied prescan function does this.
(status ttyscan file) returns the file's func.
This feature does not presently exist in the Multics implementation.
December 6, 1977 ∪3-1.8.1 Page 3-83
**DRAFT** Maclisp Reference Manual **DRAFT**
The following status functions exist only in the ITS implementation
ttysize (status ttysize f) returns the height and width of the terminal open
as the file f. If f is omitted, the value of tyo (the default output
terminal) is used. The result is a dotted pair of fixnums "(ttyheight
. ttywidth)" (cf. cursorpos). If the terminal is a printing console
instead of a display, then the height will be a very large number such
as 200000000000 or so.
ttytype (status ttytype f) returns the type of the terminal open as the file
f. If f is omitted, the value of tyo (the default output terminal) is
used. The result is a fixnum taken from the TCTYP (not TTYTYP!)
variable in ITS:
0 Printing terminal.
1 Good Datapoint.
2 Bad Datapoint ("loser").
3 Imlac.
4 Tektronix.
5 PDP-11 ("Knight") TV.
6 Memorex.
7 Software terminal.
10 Terminet.
11 Display using standard ascii display codes.
12 Datamedia.
This status call is meant only for esoteric purposes. To find out
whether you can position the cursor or erase characters, use (status
filemode).
tty (status tty f) returns a list of three fixnums which control the
behavior of the terminal open as file f. If f is omitted, the value
of tyi (the default input terminal) is used. (sstatus tty x y z f)
sets these three fixnums to x, y, and z. If z is omitted, it is not
changed. If f is omitted, the value of tyi (the default input
terminal) is used. The three fixnums are the ITS variables TTYST1,
TTYST2, and TTYSTS. Their meaning is as follows:
TTYST1 and TTYST2 are divided into twelve groups of six bits. Each
group controls a certain subset of the ascii characters. These
groups, in left-to-right order within TTYST1 and TTYST2, are:
Page 3-84 ∪3-1.8.1 December 6, 1977
**DRAFT** The System **DRAFT**
(0) ↑@-↑F ↑K ↑L ↑N-↑R ↑T-↑Z ↑\-↑←
(1) A-Z a-z (letters)
(2) 0-9 (digits)
(3) ! " α# $ % & ' , . 8 ; ? @ \ ` | ~
(4) + * - / = ↑ ← (arithmetic operators)
(5) < > ( ) [ ] α (parentheses)
(6) ↑G ↑S
(7) ↑I ↑J (tab, linefeed)
(8) altmode (ascii 33)
(9) ↑M (carriage return)
(10) rubout (ascii 177)
(11) space, ↑H (backspace)
40 Echo the character when read by LISP (normal mode).
20 Echo the character when typed (this may disappear from ITS
soon!).
10 Echo in "image mode" rather than "ascii mode"
4 Convert lower case to upper case (applicable only to letters; not
used by LISP).
2 Activation characters. If this bit is not set, then ITS will not
schedule LISP to run when you type a character within the group
even if LISP was waiting for terminal input. For example,
letters and digits normally have this bit off, since typing one
cannot terminate an S-expression, and there is no point in
"activating" LISP until an S-expression terminator like space or
")" has been typed. An exception to this rule is that for tyi
and readch LISP asks ITS to activate on any character. Normally
only groups (0), (5), (6), (7), (9), (10), and (11) are
activators. If you alter the readtable, you may wish to change
the activator groups.
1 Interrupt characters. If this bit is not set, then even if you
have used (sstatus ttyint) to set up an interrupt function you
will not get the interrupt since ITS won't tell LISP about it.
Initially only groups (0) and (6) cause interrupts (these include
all control-characters except altmode and format effectors). If
you give @ an interrupt function, for example, you should set
this bit for group (3).
On a keyboard with supra-ascii characters, one may wish to use
meta-characters for interrupts. Suppose we want meta-D to run
the function foo. Then we would turn on the interrupt bit for
group 1 (letters) and say:
December 6, 1977 ∪3-1.8.1 Page 3-85
**DRAFT** Maclisp Reference Manual **DRAFT**
(sstatus ttyint 104 ;letter D
(function (lambda (f c)
(and (= c 504) ;meta bit
(foo)))) ; is 400
- filter out plain "D"
The third variable, TTYSTS, has these bits of interrest:
40000←22 (%TSFCO) If set, output on this terminal uses the supra-ascii
convention of an "alpha" prefix for "control" and "beta" for
"meta".
20000←22 (%TSALT) If set, ascii codes 175 and 176 are ∪not converted
to 33 on input.
10000←22 (%TSROL) If set, terminal is in scroll mode.
4000←22 (%TSSAI) If set, echoing and ascii output use the SAIL
character set; otherwise, control characters are output in
the form "↑X".
10←22 (%TSNOE) If set, defer echoing of typed characters.
2←22 (%TSSII) If set, terminal uses "super-image input" mode. Not
even ↑Z and ↑← can take their usual effect for ITS.
Notice that some of these bits affect output even though the argument
is an input file; they affect the output terminal which is logically
related by ITS to the input terminal. Normally LISP or the user will
arrange for (status ttycons) to reflect this relationship.
STATUS FUNCTIONS FOR THE OLD I/O SYSTEM
uread (status uread) returns a 4-list for the current uread input source, or
nil if uread is not being done.
(sstatus uread --args--) is the same as (uread --args--)
uwrite (status uwrite) returns the 2-list for the current uwrite output
destination.
(sstatus uwrite --args--) is the same as (uwrite --args--)
crunit (status crunit) returns a 2-list of the current unit; i.e. device and
directory.
Page 3-86 ∪3-1.8.1 December 6, 1977
**DRAFT** The System **DRAFT**
(sstatus crunit device directory) sets the current default device and
directory for uread, etc. The arguments are not evaluated.
crfile (status crfile) returns a 2-list giving the file names for the current
file in the "uread" I/O system.
(sstatus crfile name1 name2) sets the current default file names for
uread, etc. The arguments are not evaluated.
STATUS FUNCTIONS FOR THE READER
See section 13.6.2 for a description of how the parameters controlled by
these functions are used. All of these parameters are kept in the readtables,
and the status functions below deal with the readtable which is the value of the
variable readtable. Note: in the following, c represents an argument specifying
a character. If c is non-atomic it is evaluated, and the value must be a fixnum
which is the ascii code for a character. If c is atomic it is not evaluated,
and it may be a fixnum or a character object.
chtran (status chtran c) gets the character translation table entry for the
character c. This is the ascii code of a character substituted for c
when it appears in a pname being read in. This feature is used in the
PDP-10 implementations to translate lower-case input to upper case.
(sstatus chtran c k) sets c's character translation to k. f2k is
always evaluated. See the setsyntax function.
syntax (status syntax c) returns the syntax bits for the character c, as a
fixnum.
(sstatus syntax c m) sets c's syntax bits to m. m is evaluated and
returned. The setsyntax function is usually a better way to do this,
however.
Note that in the above two sstatus calls, if c is a macro character it is
changed back to its standard syntax and chtran before the requested operation is
performed. However, if in the standard readtable c is a macro (i.e. ' and ;),
instead of being changed to its standard syntax and chtran its syntax is set to
502 (slashified extended alphabetic) and its chtran is set to itself.
macro (status macro c) returns nil if c is not a macro character. If c is a
macro character it returns a list of the macro character function and
December 6, 1977 ∪3-1.8.1 Page 3-87
**DRAFT** Maclisp Reference Manual **DRAFT**
the type, which is nil for normal macros and splicing for splicing
macros.
(sstatus macro c f) makes c a macro character which calls the function
f with no arguments. f is evaluated. A fourth argument to sstatus
may be supplied. It is not evaluated. If it is an atomic symbol
whose pname begins with s, c is made a splicing macro. If f is nil,
instead of c being made a macro-character, c's macro abilities are
taken away and c becomes an ordinary extended-alphabetic character.
The setsyntax function is generally a better way to do this, however.
+ (status +) gets the value of the + switch (t or nil) in the readtable.
This switch is normally nil. If it is t, atomic symbols more than one
character long beginning with a + or a - are interpreted as numbers by
the reader even if they contain letters. This allows the use of input
bases greater than ten. See ibase.
(sstatus + x) sets the + switch tk t or nil depending on x, which is
evaluated. The new value of the + switch is returned.
ttyread (status ttyread) returns the value of the ttyread switch in the
readtable. At preseNt this iS not used for anything in the Multics
implementation. In the PDP-10 implementation it controls whether tty
"force feed" characters are used. See section 13.6.2 for details of
force feed characters.
(sstatus ttyread x) sets the ttyread switch to t or nil depending on
x, which is evaluated. Again, file defaults to t. The new value of
the switch is returned.
STATUS FUNCTIONS FOR THE PRINTER
terpri (status terpri file) returns the value (t or nil) of the terpri switch
for the file, which defaults to t. This switch is normally nil. If
it is t, the output functions such as print and tyo will not output
any extra newlines when lines longer than linel are typed out. See
also the terpri variable.
(sstatus terpri x file) sets the terpri switch.
Page 3-88 ∪3-1.8.1 December 6, 1977
**DRAFT** The System **DRAFT**
← (status ← ) returns the value (t or nil) of the ← switch for the
current readtable, which defaults to t. If this switch is t, the ←
format for octal fixnums with lots of trailing zeroes is not used.
(sstatus ← x file) sets the ← switch to the value of x, t or nil.
abbreviate(status abbreviate) returns the value of the abbreviation control.
See section 13.7 for a description of the abbreviation control. Note
that the abbreviation control is kept in the current readtable.
(sstatus abbreviate n) sets the abbreviation control to n.
(sstatus abbreviate nil) turns off abbreviation.
(sstatus abbreviate t) turns on a maximal amount of abbreviation.
STATUS FUNCTIONS FOR THE GARBAGE COLLECTOR
gctime (status gctime) returns the number of microseconds spent garbage-
collecting.
(sstatus gctime n) resets the gctime counter to n and returns the
previous value of the gctime counter.
It is a good idea to do (gc) and then (sstatus gctime 0) just before
dumping out a subsystem. See also (status gcwho).
spcnames (status spcnames) returns a list of the names of all the spaces
available in the LISP being used. These are the names acceptable to
the alloc function and to the following status functions which require
a space argument.
spcsize (status spcsize space) returns the actual, current size of space, in
words. space is evaluated.
gcmax (status gcmax space) returns the gcmax parameter for space.
sstatus gcmax space n) sets the gcmax parameter for space to n.
See the alloc function.
gcmin (status gcmin space) returns the gcmin parameter for space.
December 6, 1977 ∪3-1.8.1 Page 3-89
**DRAFT** Maclisp Reference Manual **DRAFT**
sstatus gcmin space n) sets the gcmin parameter for space to n.
See the alloc function.
gcsize (status gcsize space) returns the gcsize parameter for space.
sstatus gcsize space n) sets the gcsize parameter for space to n.
See the alloc function.
purspcnames purspcnames) returns a list of names of spaces which have pure
(status
versions. See purcopy.
pursize (status pursize space) returns the size of the pure version of space.
Only spaces returned by (status purspcnames have pure versions.
pdlnames (status pdlnames) returns a list of the names of all the pdls
available in the LISP being used. These are the names acceptable to
the following status functions which require a pdl argument.
pdlsize (status pdlsize pdl) returns the current number of words on a Pdl.
pdlroom (status pdlroom pdl) returns the "pdlroom" of a pdl, i.e. the maximum
size to which it may ever grow.
pdlmax (status pdlmax pdl) returns the current value of the pdlmax parameter
of a pdl.
(sstatus pdlmax pdl size) sets the pdlmax parameter for the pdl space
to size. Both arguments are evaluated. See also the alloc function.
The following status function exists only in the PDP-10 implementation
memfree (status memfree) returns the number of words of address space not yet
allocated for any purpose (i.e. still available for allocation to
various spaces).
EJVIROJMENT ENQUIRIES
Nkte: the various enquiries related to time may return nil in the rare
circumstance that LISP cannot determine what time it is.
Page 3-90 ∪3-1.0.1 December 6, 1977
**DRAFT** The System **DRAFT**
date (status date) returns a 3-list indicating the current date as (last-
two-digits-of-the-year month-number day).
dow (status dow) returns an interned atomic symbol which iq the name of
the current day of the week.
daytime (status daytime) returns a 3-list of the 24-hour time of day as (hour
minute second).
system (status system x) returns a list of the system properties (that is,
properties whose values are supplied in the initial LISP system) of
the atomic symbol x, which is evaluated. This list may contain subr,
fsubr, lsubr, macro, autoload, or array if x is a system function, and
value if this atomic symbol is a system variable.
uname (status uname) returns an interned atomic symbol whose pname is the
user's login name. In the ITS implementation this is just the .UNAME
. In the Multics implementation this is in the format
User.Project.Instance; the dot will be slashified if print is used to
display this. In the TOPS-10 implementation this is actually a list
(proj prog) representing the project-programmer number rather than a
symbol. See also (status xuname).
udir (status udir) returns the name of the user's directory. In the ITS
implementation this is the user's "master sname", which is usually the
same as the user's name as returned by (status uname). In the Multics
implementation this is the user's default working directory. In the
TOPS-10 implementation this is a list (proj prog).
LISPversion
(status LISPversion) returns the version identification of LISP. This
is usually an atomic symbol.
jcl (status jcl) returns the "job command line" from DDT in the PDP-10
implementation. This is used to specify the init file, but
interpretation of the file name is terminated by altmode, and (in the
ITS implementation at least) additional information may follow the
altmode. The init file may wish to examine this information. In the
Multics implementation this returns the explodec'd second argument of
the LISP command, or else nil if the LISP command did not have two
arguments. If LISP was invoked by
LISP environment←name "foo bar"
December 6, 1977 ∪3-1.8.1 Page 3-91
**DRAFT** Maclisp Reference Manual **DRAFT**
then (status jcl) => (f o o / b a r)
This function is also used by subsystems implemented in Maclisp to
pick up the arguments from the command which invoked them.
The following status functions exist only in the PDP-10 implementation.
xuname (status xuname) in the ITS implementation returns the .XUNAME as an
interned atomic symbol. The xuname of a job is the name of the user
for whom it is being run. This is normally the same as .UNAME with
trailing digits stripped off. It is possible, however, to cause a job
to be run with a different xuname. System initializations should
check the xuname to determine which init files to use. In the DEC-10
implementation this is the same as (status uname).
jname (status jname) returjs the j@=DA]C5JACF↓C\AS9iKe]∃HACi=[SFAMs[E←0X ↓α&C∀4)α↓↓↓↓α↓↓↓βVsπ7∃ε{⊂∩ε∀ &}∩
_ d (λ≥-m<=1$
9→;NM9Z9.$→[tD
=λ⊂-]{Yh ≥≠λ≠lDλ≥~ T≥<y.$|c"D∧λλλ∧∧λλλ
-x\kD∧∩;H∞M→(λ ~α)P4[x62vYw:0z~ww⊂:~4yP4\β the job's .JL¬β≠
\@@A%\AiQ∀~∀@@@@@@@A Zb`A%[aYK5K]iCQS←\AQQSfA%`
β;vr2&Nαaβ←#-∪∃β;vqβ'Mπ##∃βT¬v∩α
nVn⊗↑$εNpQ$ααα∧∧ααα∧ F.≡≥\⊗bpQ!PWF-l⊗n*∧∧ααG>L↔'/4∂εFV≥\RJε≥dαπ& T∧M¬4
⊗oεL]V.wL≡FN}d∧π⊗/NX Mnh≥~ T P %∪ fbPλ0yP0[εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂4w≥2y72Y⊂0z7[tqP9↑vq7v ⊂⊂*4~yP4yH77y6Xv6<P≥42P7_vrP7Y⊂:42H897s\0vP:~0zεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂≥42P:\ry⊂4[;7urY⊂:7P_y2pz→P:44\P57q ⊂⊂*y]pv6<H:44yH;tv6λ12P:~2P9p[rP0yCE⊂⊂⊂λ⊂⊂⊂⊂λ⊂:42H570vYV⊂1:]⊂9pP≥yry⊂_pw⊂4[;7urH9r{2\0v⊂1[x4ryH7s⊂0H897s\0vP0]⊂7w1YVεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂2Xqt⊂4_{4w3H⊂0P:[4xzrH570vYP⊂1:]⊂0v6λ40{$[3P⊂:~2P9p[rP<5≠0vrWλ⊂⊂$wλ:42FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ""aVLX⊂4v\62vr[:0z4[w⊂:4~yP;t[6⊂⊂9→z:y7λ:42P~7q∪yH⊃897Yy0vPλ70vrH↔⊂⊂'[εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂&z[:4qyK⊂4z⊂≤t7zv→⊂92z≥y7⊂∀≤z0z:\P0y3H_∀WεBεE9rYv7sPλ⊂⊂∀9]0z:yH⊂9rs[7sTP≤2z:y≠9P⊂:~2P⊂6≠spy4]46P∀_0yrPλ→∀P⊂≠s⊂:4→P⊂9t↑2P⊂7Y⊂0FEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ9rsvYw:⊃⊗λ:42P≥w4z⊂≠s⊂9x_qrP0[67qp]4ww↔λ⊂∀*4→P9t⎇→P7s⊂_P⊂9rYvrw:λ72rrβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂77zλ12P:~2P9p[rP0yH:42P≤t⎇2P≠s⊂0P≠rvwy≡P80sYW∀FEβE⊂⊂⊂∃42P3≠v67{Zw3P9]0z:yH3:w1]4ww9H7w6<H2|4y]⊂4w⊂≥42P$U)P4v\62vr[:0z4[w↔εEβE4z9H⊂⊂⊂⊂λ⊂∀9z_z:yP~z9TP≤2z:y≠9P⊂0H64yzλ7s⊂3~{2P⊂~z2vyH∀7q:_tw2rλ397vH⊂:42H)ij U*FE⊂λ⊂⊂⊂⊂λ⊂⊂⊂9↑vq7v~qP9|\z2vP_pv6∀NεEεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂
_TP⊂∃42P⊂_vwzw≥⊂7s⊂λ:4vrH4w⊂⊂≤rqww→9P:w≥4v⊂⊂∩j)P4\P⊂3wZw3P2≠{w⊗⊂λ0yP0CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂367[:vV⊂λ⊗XW_λ4s⊂⊂∩j)P2≠ryw∪]⊂⊂86_w⊂:7H⊂3wP→7{w⊗λ⊂7y⊂ Y↔_⊂λ4s⊂$U)FE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂0[92pr≡P4yP→7{w↔βEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀ ∀P⊂0H34|7≥vP;t~qt⊂4\P77w≡2y7P~s⊂$j∀P4yP_2tw3H22q:Ysrr↔βEεE(_srP→K\Y⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂∧YVXW∞↔_P⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂"2Xrvq2\⊂≠⊗⊂ \[[FBβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀→TH⊂:42H7:vq→y⊂7sλ:yry≤P67sYrr⊂4[⊗⊂0yH0P34↑7:vWβEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀
∀P⊂:~2P7:[q2y⊂≠s⊂6r[wy<P→y97y≤P:42H9|yz→vP40\P9zy≥4{2r ⊂0yP_P34|≠:vWεBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀~JP⊂:4→P:4vYP4w⊂≤rqww→9P:4→P9|y]2vP4_yP12Yw⊂:x ⊂0yP_P367[:vWεB)wvrH7s⊂⊂≥44yP~w37y≠pz4w[⊂⊂6p↑P12Pλ7s⊂:\rP:7H⊂0P:\ry⊂⊂~0w26→y⊂37\⊂⊂:4→P9|yKr2pz~εE4w≥2y9:\:↔εEβE40q]97⊂⊂λ⊂∀9z_z:yP~0qz9≠∀P92]:y79H0w⊂⊂_z7vtXP9|vX7v⊂4[24qp]4w3P≥t0z⊂~tw2⊂λ7s⊂5≠qεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂4\P9zx→y4wyλ:7P⊂≥42P&∩ih↔⊂λ!zy9→w:⊂8≠yytq~v4z4YyP⊂0\2P22≥⊗⊂&$Th⊗⊂⊂≥⊂∀0FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ9zx2\4wy⊂≠s⊂:w~w7{wλ:<x2JV⊂0w→⊂74vλ∀77P≤zx2y~wy∀WβEεE⊂λ⊂*42H37v6≠{tw3H9z0z≥yP3:[1z4w[9P2|~yz⊂7[6<P4[⊂:42H&zv:~qyP4[x62vYw:0z~ww↔εBεE80Ytw3Pλ⊂⊂∀9]0z:yH80st[3TP⊂≤2z:y≠9P0Pλ64yzλ7s⊂:~2P⊂8_stw3Kr2{4XrP80YrP⊂9→pr9P_w2εEλ⊂⊂⊂⊂λ⊂⊂⊂⊂≥7z0vλ80srH92pr≤P:40]⊂40{→P12r[⊂1pz\rr⊂1≡P:44\P897XryyWβEεE0\3P⊂⊂λ⊂⊂⊂∀≤z0z:\P⊂0y→P⊂7∀H92z:\79P⊂≥42P⊂≠∃XSz~⊂0y3]vrw:λ⊂7s⊂λ:42Pλ1wvvXw2⊂;Z4qtεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ4w;7Zrr⊂⊂≥42P⊂≤zq9|\z2vVλ0yP⊂_w⊂⊂4[:2y7→r⊂0z≠vtqPλ9|vq≠v↔⊂⊂λ∀*42H34y9]εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂0y→zvrw≥⊗⊂⊂∀≤z0z:\P0y3H⊂_∀Vλ⊂4yP≥42P⊂≠0vrPλ7s⊂:~2P⊂9]q9|y]2vW∀H⊂74vλ4yFEλ⊂⊂⊂⊂λ⊂⊂⊂⊂≤2z:y≠2r⊂4Y⊂7⊂4\P3y2Xz2y⊂≥40w⊂≥42P7≥vq2yλ7s⊂0\3zvr[:9P:≠P:42H1wvvXw2↔εBεE)j⊂j*iP⊃*g!j∩gg)P⊃'i⊂*∩"P+d∪Vf$g⊃FEεEλ⊂⊂*4→P37v≠7{tw→P9z0]:yP3≥w1z4[w9P2↑4yz⊂≠w6<P~w⊂:4→P$j)H4vx6→vrw:_z4ww εEεE≥t7v⊂λ⊂⊂⊂⊂
9yz0]:yP;Z7v⊂0H⊂1⊂1H2∀P9Yz9P⊂→7zy⊂≥yry⊂≤0y0vYz2y9H37y⊂λ:42Pλ;t7V[4w2QβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂;t4Xt⊂0x≤2py9H0z⊂:~2P17]:7vP≠s⊂9w[rP24\x60|H:2y6Zw0v9K⊂⊂⊂*~2yrP_ww:9≠vεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂:~2P89~w:⊂3≠y6pzλ7s⊂4[37y6Xz4wwλ9x2qZs4rrλ1<P∀≤yz0z≥yP⊂;Z7Y∀Vλ∀9yz_z:yFB⊂⊂⊂⊂λ⊂⊂⊂⊂λ;t7YJV⊂0w→⊂⊂∀9\z0z:\P3q{Z7TW⊂λ⊂"pqZ⊂7s⊂λ:42P→7zy⊂λ80y0[rz2y≤P9x2Xts4rYεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂2tYt:⊂1~ormation. Parameters a and c must be fixnums; b and
d may be fixnums or atomic symbols (which represent the ascii value of
the first character in their pnames). Their meaning is as follows:
a If 1, suppress display of entire who-line.
200
100 If 1, suppress space between halves of who2.
70 Mode for printing high 18. bits of who2.
7 Mode for printing low 18. bitq of who2.
b If non-zero, print between halves of who2 as an ascii character.
177
200 If 1, Print chabacter twice,
α
c If 1, suppress space between who2 and who3.¬
200
@ec@∃[EKdhX@bdnf@@@@@@@@@@@@@@@@&f4b\`!s ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓αC∞;∃↓MkIL4(1)*%∩ε~QRQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓∧kπ∂3M≠AαK,3↔K↔v≠∃α↔∞sWπ⊃α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓%(E∀ j@
E! C"AQHλλ∧∧λλλ∧∧λλλ∧∧ -edλ<h⊃M}H_ ⊗λ1:z_q32a]9P;t≠YSεEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂2⊂⊂λ yP#≠y⊂1, butabfe@
ifAo!↑fL~(@@@@@@@@fnn~(@@@@@@@@↓)QChαβ'MD∧εN∩∞Mε*π⎇
rnf≥lRαε≡4ε&O> F∂N\@ε∂"∧ ⊗fBβλ⊂~~2P⊂:\py⊂ )nfgrmation
ap@AKCef↓S\Ai!JAM←β∪5h∀Ph)↓↓α↓↓↓↓α↓αBBα→
-~~∃ m**%∀∧¬:5≥≥1Q hR∧∧ααα∧∧ααπ⎇ W⊗+!Q hR∧∧ααα∧∧αα¬
¬αα∧
&/∨]JBε↑d∧ππ⊗≥nFNvt
FF*
⊗.Bε∪αbα -↔'~
|bπ>
v"ε∂4∧π∨ε\9⊗&N\@ε↔HQ$ααα∧∧ααα∧
↔4≥~→!QHλλ∧∧λλλ∧∧λλλ∧∧_)|dεlλ_M≡≤kC!!"Hλ∧∧λλλ∧∧λ∀4*~(λλ∧ Z9≤d
yH≥m
lKλ /(_in4
h⊂M≡≤kC!$λλλ∧∧λλλ∧
≠⎇hε↔ C"AQHλλ∧∧λλλ∧∧∀TTJ$ . D Z8
9H7s⊂;Z7YV⊂_<P1S\P≠X⊂_4z9WβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂44sZεEεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂∀iiiPλ⊂⊂14]9P7sλ;t7YK⊂1<P_SyP≠H14z9KεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂67]P_\↔βEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊃HP⊂⊂:≠P:;wH1t0y_qz2y≤V⊂9x→qts4Yr⊂1<H2↔εEλ⊂⊂⊂⊂λ⊂⊂⊂⊂≡2y7FBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊗Pλ⊂⊂⊂⊂≥w62y\P0SyH_X_⊂_4z⊂4\P9rz εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂9x_qrVεBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂≡Pλ⊂⊂⊂⊂≥w62y\P1SyH→__⊂_4z⊂4\P9rz εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂9x_qrVεBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂∃Pλ⊂⊂⊂⊂≥w62y\P1SyH_X_⊂_4z⊂4\P9rz εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂9x_qrVεBεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂*4→P87y\tq62H894w≥⊂6wr→yP0y→]εEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ_⊂⊂7≠z⊂89~w:↔εB⊂⊂⊂⊂λ⊂⊂⊂⊂λ"7FEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂_P⊂λ⊂4w⊂≤0qurY⊂37y≠]εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂"_z2FEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂≠[Z __⊂,Ypy⊂6[r⊂_X ↔εEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂→[ _⊂&w[:4⊂∀∩0w:p\<P≡P TFEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂_MZ⊂"0↑P7s⊂≠ww:4 εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂(9~w:2rλ0yP6[Wr2↔↑|WεEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂→⊂⊂λ⊂4w⊂→7y:4Yz49P≠s⊂0P≤rqww→↔⊂⊂(≤4w:2Y⊂0yP~4≥6vN9yW: εE⊂⊂λ⊂⊂⊂⊂λ⊂⊂*4[rFEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ→P⊂⊂λ4w⊂4_v3⊗yYqww2≤V⊂89~w:2rλ0yP4~≥6v]≤yWεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂∃4vrFBεE(0YrP→VNZ⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂ LVXW≤ _P⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂"2qYvq2yλ≠⊗⊂_N[[FEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ*42P∀|yz2[P⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂λ⊂⊂⊂⊂λ⊂~⊂⊂λ⊂⊂7:[q2y↔βE⊂⊂⊂λ⊂⊂⊂⊂λ⊂'qz_vεEεB⊂⊂⊂⊂λ⊂⊂⊂⊂λ~P⊂⊂λ⊂⊂⊂7≥vq2yλ∀77Pλ↔⊃⊂4\P894[:2r∀KεE⊂⊂λ⊂⊂⊂⊂λ⊂⊂"2XtvpvβEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂≠λ⊂⊂⊂⊂≤t|14]⊂1t0\0qz2\9WεEλ⊂⊂⊂⊂λ⊂⊂⊂⊂∃492rCEεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂≠CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂*w:\rr↔εB⊂⊂⊂⊂λ⊂⊂⊂⊂λ∀9z0]:yP;Z7XTP≤2z:y≠9P0P≠4yz⊂≠s⊂37]y⊂34↑7:vyH∀0P1λ1P2∀KεEεE≥t7Y⊂λ⊂⊂⊂⊂
9yz0]:yP;Z7Y⊂<
P9rz≤P:42H;t7Yλ;0y4Xq62P≥7P<⊂~s⊂4zλ4yP0H34|7≥vV⊂⊂≠y⊂:7CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂:42H9t|1~z⊂;0[:rP7Y⊂:42H34y9]⊂⊂9t↑⊂1t0\0qz2\9P7sλ:42P≤70vrH7s⊂<λ⊂4s⊂~zεE⊂λ⊂⊂⊂⊂λ⊂⊂⊂4\P0P9↑vq7v ⊂⊂∀9]0z:yH;t7Yλ<∀P9→z:y7≤P;t7L⊂0yP_P34|≠:vWεBεE;t≠YP⊂⊂λ⊂⊂∀9\z0z:\P;t7LP<∀P_w2⊂∀≤z0z:\P;t7LTP0y→P0w0[7swz\P:7P≥47yrH37y⊂≥t7Y↔βEεE"↑0vx6→]εE⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀_v6⊂7≥vq2y≤P4w⊂≠qz0v
FE⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀9\z0z:\P;t7LP_[≠λ_⊂_Z
⊂→~Z
FE⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀9\z0z:\P;t7L⊂∪c'Sa i∀CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂∀9y]0z:yH;t7YH∀∃P∀∪)d⊂_L→Z⊂→ ∀P→Z
[∀TFB;wzv→⊂1pz\rP⊃#∪ga iλ_Y→Z ⊗→Z~M⊃⊂:7H0x82Xy⊂4wλ:42P≥t7Vv~w2W⊂λ*42P→rw2y_v⊂⊂4Y2pP4\FE:4_z⊂:4→P:yr\⊂9t7]v2⊂9Yz⊂:xλ;t7XH5:yzλ7w1rH0w2⊂≥42w⊂~rrx⊂≥x20z~w3P;Z7Y⊂⊂_w2⊂;Z7YFE_yP0x≤97x9~pz2Wλ⊂#7yλ2|0v\62V⊂_P97z]4w3P≥40z⊂≤97qr\yrr⊂→:w1z~ww9P~w⊂⊂3~v2yP≠tst:βE27FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀≤yz0z≥yP;t≠XP_[
⊂_⊂_M≠⊂_∀CE0w2λ7w⊂7\2w4w→P0P7→{P34[2P27CE⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂
9yz0]:yP;Z7Y⊂∀_pr9⊂
:9:w_vrP4[34v2JTTFEλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂∀9\z0z:\P;t7LP_∀FB0w2⊂≠w⊂2w_wzw:→y4w3H0P3:[1z4w[⊂27FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂∀≤yz0z≥yP;t≠YP37≠0vrTCE0w2λ9wP1[w:4w≥wzyv≡P24y\60|P≥42P3~v2w0[rP0w→⊂3:w_z4wwλ70vrH12tw→P897XryyrY↔⊂⊂'[2FE0Y;0w:_srP7Y⊂27t[3P⊂:~4yP7]2y⊂8≤4w:4[3P:4→P⊂4w→7y6p]4ww⊂~yP:4_z⊂&$Th⊂⊂1Xw⊂:x→0z2FB;t7V[4w2P~w37y≠pz4w[⊂2{2[⊂:47]st⊂4]⊂27r\w∪z⊂~0{2P_ww:9≠v⊂7sλ:42P_ww9w[2WεEβEεE3X{t7Pλ⊂⊂⊂∀≤yz0z≥yP3q]t7P7
P9rz≤P:42H3q{t≠P9{t]1t⊂:≠P7↔⊂λ!zy9→w:6<H7w6<H⊂:42H67{FB⊂⊂⊂⊂λ⊂⊂⊂⊂λ:;wP_4z9P_y2P9Zsw4s~qpw: εEεEλ⊂⊂*4→P⊂_P_4z⊂⊂≠rpw9H:40zλ⊂2:y~w3P0H⊂3py_0srP_wv62Xz4wwλ⊂:42H;t7V[4w2Pλ9t7z[2⊂12CE:yz\82r⊂≥7P⊂2~yx60↑P:42H6ryyXsrP⊂λ#a],⊗,,⊃⊗λ;t2y→P⊃,,⊗,⊃⊂⊂~yP:4→P92p\ww⊂⊂→7y⊂:~2FE3Xy10sYP1wv≠2qz4[w↔⊂⊂∪w⊂1w[x62z~ww⊂⊂≠s⊂:4→P3py_0srP_wv62Xz4wwλ:42Pλ7y4sZw0v⊂≥yryεB;t7V[4w2P~w37y≠pz4w[⊂4yP≤2yz7\2r↔εBεEεE⊃2qrvX2y⊂≠ ⊂_\[MP⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ YVXK≤↔_Pλ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ(0srH→V\ZCEβ∃∃")⊂c*∃∃λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂&Xqv4y\⊂)2s→y2w1YP&pw≥pv⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂⊂⊂⊂λ⊂∃∃"∀ c*∃
εEεEβE⊂⊂⊂∃42P→λ⊂14zλ6rpw≤P⊂:4_z⊂0zλ⊂:42H2w2⊂≠s⊂⊂:~2P3p\10srH⊂1wv≠2qz4[w⊂:4→P⊂;t≠Y⊂;w\2εE9Z7zv2λ12P0[:2y2Y⊂9wPλ:40zλ:42P≠7{P_N↔⊂14]9P⊂3Yz⊂:4→P92y]v:⊂7Y⊂⊂∀9]0z:yH3qz4[rTVεB1ww;→y:2rλ:7P3≠y:4r]49P7Y⊂0P9Yqww2 ⊂0w2λ⊂:42H44stλ_\⊂1~z9P3Yz⊂:4→P92y]v:⊂⊂≠s⊂∀↔KFE∀∃λ∀9z0]:yP3Xz4vrJP_X_ ∀T9:[:4vrJTV⊂;Z4qt⊂~yP:4→P82y_rw:0YrP7sλ:4vrH9x2w≥⊂4w⊂→qWεE∩s⊂:4→P:yr\⊂3t{→yP~Yλ7qz0[⊂0w2λ∪RP0\P:42H34y9]⊂:;wH0y3z[rw:9H:7P⊂
9yz0]:yP;Z7XTVβE:42[⊂:42\rP8zXw:4z~ryP;Zv6⊂1→P24y\60qrY⊂4w⊂≥42P3≠y6P⊃≠7∩P4~≥6vM≤yW:⊃ ⊂⊂5:\z⊂64ZrFE:~2P9z_w20y→⊂9|y]2vP9]0z4y]4qyPλ37y⊂≥42P&∩ih⊂5≠q↔⊂⊂λ*42P≥yry_pw⊂9]4v6⊂λ:yrP≥t7YFB37y⊂~4yP7]w⊂8:\87yr\UεEεB⊂⊂⊂)]q9|y]2vyP≥t4qtλ:yrP
9yz0]:yP3X{t7TH9t7z[2⊂82\37y6CE
(gc)
(sstate@LAOGi%[@∃↓αH4+ ,3?K∃αβ∪W↔εK;≥β␈+Q↓β&C∃βO,∪OgO&+5 "∧∞6zα∞Mε∂"∞Mε*α |2π&≥\Rαπ Z&≡.nL⊗>/4∧π>NMDε⊗(Q(λ,<⎇<X.L( C!! ¬⊂⊂λ∀9z0]:yP3X{t7TH92z:\59P*~2P;0[8¬e od∧AiQ∀AOGo!↑Ago%iGP\4∀~¬≠%'π →1β∃ ∨U&A'$
RVM∧2V:∞αI∀l@Tc"AQY=P-M≠{rd∧nables the evalhook feature; (sstatus evalhook
nil) disables it. (status evalhook) returns the state of the switch.
See page 3-32 for the details of this feature.
toplevel (status toplevel) returns the top-level form, which is continually
evaluated when LISP is at its top level. If this is nil, a normal
read-eval-print loop is used.
(sstatus toplevel x) evaluates and returns x and sets the top level
form to this value.
For example, to make Maclisp have an evalquote top level similar to
LISP 1.5:
(sstatus toplevel
'(progn (print *)
(apply (read) (read)) ))
See section 12.1 for further details.
breaklevel (status breaklevel) returns the break-loop form. (sstatus breaklevel
x) sets this form. See page 3-6 for how this is used.
Page 3-96 ∪3-1.8.1 December 6, 1977
**DRAFT** The System **DRAFT**
uuolinks (status uuolinks) returns a number which represents the number of
available slots for linking between compiled functions. (status
uuolinks) returns nil if no uuolinks pages have been set up yet (see
pure). Otherwise it returns a list of two items. The first is t if
area 2 has been purified (and so no new calls may be put in the area),
and nil otherwise. The second is the number of slots not yet used in
the uuolinks areas.
(sstatus uuolinks) causes all links between compiled functions to be
"unsnapped." This should be done whenever (nouuo t) is done to insure
that the interpreter always gets a chance to save debugging
information on every function call.
divov (status divov) returns the state of the "divide overflow" switch. If
this switch is nil an attempt to divide by zero causes an error. If
the switch is t the result of a division by zero is the numerator plus
1.
(sstatus divov x) sets the "divide overflow" switch to x.
In the PDP-10 implementation, divoV applies only to quotient. // and
//$ do not detect division by zero.
mar (sstatus mar cond loc) arms the mar (memory address register)
interrupt (currently available only in the ITS implementation).
(status mar) returns a list of cond and loc, or nil if the mar feature
is not in use. See the mar break feature for more details (page 3-
56).
features (status features) returns a list of symbols representing the features
implemented in the LISP being used. The following symbols may appear
in this list:
bibop PDP-10 big-bag-of-pages memory management scheme
lap this LISP has a LISP Assembly Program loaded
sort the sorting functions described in chapter 11 are
present
edit the edit function described in chapter 18 is
present
December 6, 1977 ∪3-1.8.1 Page 3-97
**DRAFT** Maclisp Reference Manual **DRAFT
*
fasload the fasload facility described in chapter 14 is
present
↑f the "moby I/O" facility is present
bignum the arbitrary-precision arithmetic package is
included in this LISP
hunk the hunks data type and its associated functions
are present.
funarg the "fake funarg" feature (second argument To eval,
third to apply, etc.) is present.
strings character strings afd the functions on them
deqcribed in chapter 8 are present
newio the I/G fqncTions descpibed in chapter 13 are
included in this LISP; id∧AiQ%f@AM∃Cike∀@ASf↓]←h~(@@@@@@@@@@@@@@@@@@@@@@@@↓aeKg∃]h@@↓←]Yr@Ag←5J@A←_@@Ai!←gJ@AMk]
iS←]L@ACe∀~∀@@@@@@@@@@@@@@@@@@@@@@@ACm¬SYCE1J\~∀4∀@@@@@@@@@@@Ae←[¬\@@@@@@@↓iQSf↓→∪' AGC\↓eKCH↓C]H@↓aeS]PAe←[¬\@A]U[KeC1f@Qg∃J~∀@@@@@@@@@@@@@@@@@@@@@@@AE¬gJAC9HASE¬gJ\~(~∀@@@@@@@@@@@Aie¬GJ@@@@@@AiQJ↓ieCG∀AaCG-COJ@!GQCaQKd@bTRASf↓aeKg∃]h\~(~∀@@@@@@@@@@@AOe%]IKL@@@@AiQJ↓Mk]GQS←\@↓IKMS9SiS←8AM←e5CiiKH@QGQ¬aiKd@blR↓Sf~∀@@@@@@@@@@@@@@@@@@@@@@@AAeKgK9h\~∀4∀@@@@@@@@@@@AOeS9H@@@@@@@↓iQJA→SYJA→←e[CQiKd@!GQCaQKd@bXRASf↓aeKg∃]h\~(~∀@@@@@@@@@@@AG←5aSYKH@@@@AiQSLASfAQQJA→%' AG=[aSY∃d@QG!CaiKH@bhRAeCi!KdAi!C\~∀@@@@@@@@@@@@@@@@@@@@@@@AQQJAS9iKeaIKiKdQgKJ↓CYg↑↓G←[a%YKd[MiCiJ$\~∀~(@@@@@@@@@@@@↓MCgi¬eSiP@@@AQQJ@A→Cgh[¬eSiQ5KiSF↓MKCiUeKf@↓←LAi!J@AG=[aSY∃dACe∀~∀@@@@@@@@@@@@@@@@@@@@@@@Aae∃gK]h4∀~∀@@@@@@@@@@@A[0@@@@@@@@@AiQ%fA→∪M ASf↓←\Ai!JA≠CQQ→CD↓[CGQ%]JACPA≠∪(4∀~∀@@@@@@@@@@@AC$@@@@@@@@@AiQ%fA→∪M ASf↓←\Ai!JAβ∩↓[CGQ%]JACPA≠∪(4∀~∀@@@@@@@@@@@A[ @@@@@@@@@AiQ%fA→∪M ASf↓←\Ai!JA≠ε↓[CGQ%]JACPA≠∪(4∀~∃!¬OJ@f4rp@@@@@@@@@@@@@@@@@@@@@@LfZb\`\b@@@@@@@@@@@@@@@A K
K[EKH@lX@Drnn~( **DRAFT** The System **DRAFT**
SAIL this LISP is running at SAIL
H6180 this LISP is on an H6180 Multics machine or a
compatible machine such as a 68/60 or a 68/80.
its this LISP is on some ITS system
Multics this LISP is on some Multics system
TOPS-10 this LISP is on some DEC TOPS-10 system; or on some
TENEX system since the TENEX implementation runs
under a TOPS-10 emulator.
A package being "present" means that it has been loaded into the
environment. If (status features) claims it is not present, it may
still be available because it may be automatically loaded when
required. This does not apply to the compiler.
(car (last (status features))) is an implementation name, such as ITS
or TOPS-10 or Multics. The main idea behind this status call is that
an application package can be loaded into any Maclisp implementation
and can decide what to do on the basis of the features it finds
available.
feature (status feature foo) is roughly equivalent to (memq 'foo (status
features)), i.e. it determines whether this LISP has the foo-feature.
Note that foo is not evaluated.
(sstatus feature foo) makes foo a feature. foo is not evaluated. For
example, the trace package does (sstatus feature trace) when it is
loaded.
Example:
December 6, 1977 ∪3-1.8.1 Page 3-99
**DRAFT** Maclisp Reference Manual **DRAFT**
(cOnd ((status feAture bignum)
(prog2 nil (eval (read)) (read))) ;use first
(p (read) (eval (read)) )) ;use secOnd
(defun factorial (n) ;bignum version
(cOnd ((zerop n) 1)
((timas n (factkrial (sub1 n))))
))
(defun factorial (j) ;fixjum
only vers@%←\~∀@@@@@@@@@@@Q⊃↑@PRPQ]←P@P|A8@bf\$RR@@mI↑Ak9iSXAαq↓p"z↓EM_hQ↓↓↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓#↔↔∪?I↓⊗ K∨Wn+;Qβ&{=β N9↓5β4∧⊗∨&}-⊗∞b!Q"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα
aPRα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧w?⊗lqW'O UV∂⊗u∃⊂hR∧∧ααα∧∧ααα∧∧ααα∧¬ε≡}lDαBG,↑&␈α
a∩β
⊃Q"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααᬬαRεd¬ε6∞>Mw⊗N≥DαC
T
bJJ∃∀αJHQ!PVv|lV∂'↑,RαG>>F∂'↑4αεv|lV∂'↑,Rε6⎇u∩αε\≥6/~∧ f}z
mw"α ,Rαε∀λf.∂NZ&*r∧∧ε6↑t∧εO~
mw H$∧ααα∧∧ααα ↑f∞g\≡F."aQ hR∧∧ααα∧∧ααα∞>F∂'↑4εv}lX↔'/,Tε6}u∀εO~ Z↔.Ol≥F∞wD
Fzα
mw"α∞>F∂'↑4ε6.≡NW⊗* ivzJ∃aPPh.>F∂'↑4ααα¬∞7&∂NZ2π∨L≡G/~ mvzJ∞,W'∂-n2π"∧
⊗"εm⎇rεO4 ∩π6≥M⊗"π>L↔'/4∧ε7.l>FN}edα∧NaQ"αα∧∧ααα∧∧εO"
≡2εv}EBεv≥DεO~∞,W'∂-lV"pQ!PRα∧∧ααα∧∧ααG>L↔'/4∞7&∂NZ2Jπ,↑G/⊗n4ε
α
M↔∨"
|bπ6≥M⊗"π>L↔'/4 g.v>M⊗}w5dαα¬M Rεv≥\W_h$∧ααα∧∧ααα ≡&*πN.Vv≡≡LV"πMtαπ≡⎇\RεN↑
F.n]nF∂&≥⎇bn&↑ Vv&]nBεw]\&/∩∧
v"ε= ↔⊗∞>LW↔~AQ"αα∧∧ααα∧∧π∨.=∧ε∂~εDε␈∩εU`hPQ.7∨&≡NW~α∧¬π∨&≡NW~π>>F∂'↑4ε6}u∀π⊗/N↑&w~∞DεN2 mvzε≡4ε
πl≥FN"∞>7&∂N↑2ε7]l7&N⎇ebα∧≤aPRα∧∧ααα∧∧αεOD
↔~εm}Bbεm≥BεO4∞&/'↑-f."aQ hR∧∧ααα∧∧ααα∞>F∂'↑4π∨∨L≡G/~∀∞&/'↑-g~ε∀∧εfO>Dε}2∞l⊗fND∞7∨&≡NW~εn]f∨&≥⎇g~r∧∧∧∂~∞⎇↔&@Q$ααα∧∧ααα∧¬π∨&≡NW~α∞>F∂'↑5∩bα∞Mε*α
l⊗n/4 ↔⊗*∧∞G↔.l<↔&.D∧π&z∧∞6}nT
⊗oεL]V.wL≡FN}eQPRα∧∧ααα∧∧αε&↑ Vv&]nBεw]\&/∩
|bε≡ ≡&∞∨L↑'~b∞>V≡B ≡2β"
}"β*aQ hPQ&∩sBf$α¬&≥\PhPQ!PPh!Q hU ≤v*β5V∪βα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧αααα62k
g¬c
α∧∧ααα∧∧ααα∧∧ααα∧∧α∧&\<Vn⊗↑$β2bε↔∪;8Q bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hW.]g&N\Tααα∧∧ααα∧∧αα¬:X%∩εmtε∂⊗}1PPh$∧ααα∧∧ααα¬∞'.wM≥V*J∞,W'/-n2ε∂4 ∩ε6∨
g.j∧∞FF*
nVn⊗↑$ε}2
]⊗∨⊗}<V≡}lN2ε}d∧ε∨πT∞FNnQQ"αα∧∧ααα∧∧π/≡\Dπ≡z l↔∩ε/∀π&FT∧ππ⊗|<W∨~
≥bπ>
≤6B∧I~5αε≡4π↔.mm⊗v:d∧α¬& Tε&NllW⊗.l<PhR∧∧ααα∧∧ααε,↑G>.]dπ'>t∧π6∞N\W~ε|dαG↔]nFNnU∀αεNlM⊗≡∂L↑2π& Tε∞n}]g"α
|bε≡⎇↑π/&≡M⊗}pQ$ααα∧∧ααα∧∞FF∂D∞v∂~ Mvv* ,W'>\]bπ& Tπ'>t 6∞fN4π&z∞.Vw&≥\Rph!Q hWM≥V*α∧∧ααα∧∧ααα∧∧αα¬:X%∩εmtε∂⊗}1PPh$∧ααα∧∧ααα¬∞FNnU∀π⊗/N↑&w~∞Mε*πM≥V*ε≥dπ≡.=⎇f'~∧∞FF∂D∞FF*∞?↔∨&]TεF∂4 &..d∞Wαb∧ ↔~ε⊃Q"αα∧∧ααα∧∧ε6f⎇nVjr∧∧¬&FT FN6l↑&.v<Tαε⊗↑Nv..d∧π&FT∞&/∨]NG~α
|bπ'⎇tαε≡≥MG~α∞Mrπ&≥\PhR∧∧ααα∧∧ααε≥lFN≡≡LW~α∧∞FF*∧∧ε∞n}]g"α
|bαα ]F∂π<\Bαα∞,V∞b∧∞FNnUdααα¬ ⊗rα∧∞FF*∧ ∃%_Q$ααα∧∧ααα∧
⊗oεL]V.wL≡FN}eDπ&N\Tπ&F≡Dε.f≡∞6/~∧∞vFNLTπ&FT∞7O∨L]RεO4∞7&␈∞ V"α NV*πMqPRα∧∧ααα∧∧αεn]]w↔J ↑'⊗␈.4εO~
mw"α =vw≡≤LW⊗.D∧'⊗.≥D"ε∞lDεv␈D 6␈.nLV"r∧∧¬/≡T¬π∨&≡NW_h$∧ααα∧∧ααα L↔O&≥\RJπMtεn.≡>W⊗*∞N'.*∧.&.∞D∞v␈⊗LD"π&≥\RrHQ!PPh.=F./∧∧ααα∧∧ααα∧∧ααα
:T∃∩ε∀ε∂⊗qQ hR∧∧ααα∧∧ααα∞=F./∧
bJε<≡W≡/4∧ε
π,\⊗boM≥V*εL]F∂J
|bαεd∞6.≡⎇lG~b∞Mε.r∞,W'/-n2αεedαεpQ$ααα∧∧ααα∧
V∂J ,Rε
m↔Fw]Tε␈∩ ∀ε6f⎇nVjpQ!PPh*<V*ε≥N6zπM Rε∞L≡&n≡M|6Zεn]f∨&≥⎇bbπ<\7&N⎇dβ
sEf2bε≥lBπ& Tε&∂LUBε&∨≡FNnUDαε∞lDε&␈qQ&7.l>FN}n4ε}2∞Mε*π>L↔'/4∞7ε.=≤⊗bεm}&jb LW≡∨-≤&."
≥bπ& Tππ⊗\<V&Nltπ≡.>M⊗}raQ hPQ&∩sBf4α∧/<<↔εNltε7⊗⎇T∧dM:↓PPh!Q"αα ≡BεO4∞ε␈∨=≤&f*∞Mrαε↑<6∂εT∞F.o
}&∂⊗≥O∩ε7-⎇R∧d~:ααπMtε/F\>W&* ∀ε≡}]\⊗v"∧
⊗rπM PhV
}7"α
}ε/⊗≡M⊗v:∞?↔∨&]Ubαα |bε≡}↑'≡*D∧π&FT∞π⊗}},⊗jα¬
w∩π↑<W∩J∧∞FF∂D∧π∨/∞
FN/4∞FF(Q,6}n\≥f"ε ≡2απMtε↑v}tπ>F≤=ααε} W⊗∂M≥f:π?≡7&.T∧εO"
≡2π↔]mfNvt∧π.vL↑"rα ≡Bαε≡4ε∞g=qPWε}>6N⊗LTε6␈$∧∧dM:∧π&z∧∞&/'↑-bπε↑-V∞v]nFgJ∧∞FzπM Rαε
}7"ε} W⊗∂M≥f:α∞?↔∨&]Ubα¬M
↔_h,M↔≡≡≡,G~πM R∧d~:αε.nm↔⊗}m\Vw" ≥f"ε⎇≡f/~ ,⊗≡Z∞⎇ε∂&↑lW∩π,↑6␈/,<W~b∞>V≡B ≡2εn]]w↔JAQ&O"∞|↔~π↑=⊗v:aQ hPQ!PPh!Q hPQ(F.≡]\&/∩εeBβ ⊗vrαα∧∧ααα∧∧ααα∧∧ααα∧∧↓≠~V∃cBs$∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧
ε∞>Tε2k ε⊃PPbR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧ V∞≡M≡7α¬,\f/⊗]l6*∧\≥g.∞D∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ jE"Ph!Q hR∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααε≥dπ&FT W.gM≤7~ε≥↑εf.\]g&∂M≥vph!Q&≡f≥lRαα∧∧ααα∧∧ααα∧∧¬≥,*$β
ε≡,phPQ$ααα∧∧ααα =FNvT∂αJb∞⎇ε/⊗T∂αεO4 ∩ε≡ ≡&∞∨L↑"π∨N-⊗v:D WF.>↑F/~∞Mε*∧↑]G&N>4ε≡}]\⊗v"∂↓PRα∧∧αε∞lDπ⊗/N↑&w~
m⊗br∧λWF∞↑
F+PQ$ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧¬ε≡f≥lRα↔⎇
rαnM⎇f:∩
quit SUBR no args
(quit) returns from the LISP command, freeing up the temporary segments
that were used to hold the LISP environment.
in the ITS implementation
valret LSUBR 0 or 1 args
(valret) does a .LOGOUT if LISP is a top level procedure, and otherwise
valrets ":VK " to DDT.
(valret x) effectively performs an explodec on x (in practice x is some
strange atomic symbol like |:PROCEED :DISOWN | , but it may be any S-
expression), If the string of characterq is one of "$↑X.", ":KILL ", or
":KILL↑M" then valret perforis a "silent kill by executine a ,¬¬% ¬⊗~∀@@@@bXXd``@`vA←QQKeo%g@∃β6 3K↔ βC↔K4{C /4∧ε
αh¬P)J1+λ ]=Z3LT≥~→$∧_z_. 8⎇→.∧≤⎇≤M≥Yc"D∧λλλ∞MβP""∃⊂:7P→{0v*Xz2P0\P1w`-mafds, α
EXampl@∃`
hQ!PBα∧∧ααα∧¬π6∞L,W"α␈G%¬∀x8T,"¬(DM≤zybπbα#"AQHλλ∧∧λλλ∞>_8]∞∀≥~→$ ∩4t∧∞];[M≥Yh∪md~=≤d
⎇{@⊂≥tz47]z⊂0@≥2y6t[0p .
λ ∀@@@@@@QmC1` ↔Qα;q↓j\J21↓U"⊗∞≡tkq$Q!PBα∧∧ααα∧
6NfN4π&FT DM≥∧λ⊗v"∞:F∂↔L4π/α ⊂¬$ 9u`hPβ"H∧∧λλλ∧∧
≥X-NY=⊂ X∩'α∀∀@
λ Cause@LA↓ (↓iP≥β¬∪';Q∧¬w/"∧
FF* 8 mn→;]∞P7s⊂_v6⊂'≠w⊗⎇2\αo lOcati@=]f@AαK9αI~5HαHλ∧∧λ_;LD≥~→-d≤Y5∞↑Xπ⊂*≠P ISP.
αPaga #-102 ∪3)1.`X M↓α↓↓↓↓α↓↓↓↓α↓↓↓↓α↓↓α∪,≠↔7 ,ε"β2Dε∪K≠qQ bR(J$ 5E%"αα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧α¬& T¬∨O>LVjα∧∧ααα∧∧ααα∧∧ααα∧∧ααα∧∧ααα%(E∀ j@
E!"C"AQHλλ∧∧λλλ ≤β⊂:4→P⊂;0[92z_wvvp[2⊂⊂6→p{2iH<wzP~w⊂⊂"⊃*⊂∀7\⊂⊂0w≡{t2y→P7z4→y⊂⊂:~0w⊂:~2FE⊂λ⊂⊂⊂&∩ih∀Vλ0P∃!Sg*$g∃bP7`2 $P command to D@ (A]SYXAIKike8Ai↑AQQJA→%' XA]QSGP↓oSYX4∀@@@AiQK8AeKiUe\AMI←ZAi!JAGC1XAi↑↓mCYe∃h\@A!←oKm∃dXAm¬YeKh↓ISMM∃ef@A→a←ZAMkgaK9H~∀@@@AS8Aio↑↓oCsfh@ASh↓I←Kf↓]←hA
QKGVAM←d↓←aK\↓MSYKLXAC]⊂AShA⊃←KfA9←h@A¬YiKd↓iQJ~(@@@@↓giCeQS]NA¬IIeKMfA←L↓iQJA1∪' \A∪LAe←jAkMJAmC1eKhAQ↑AIk5`AB@↓gkEgegiKZ0AiQK8~∀@@@Agi¬eiS]≤Ak`AQQJAgUEgsgQKZAG¬kgKfABAe∃ike\↓i↑Ai=`AYKYKXAC9H@Ai!JAG←9gKck∃]h~∀@@@A∃mCYk¬iS←\↓←LAi!JAi←@[YKm∃XAKeIYSgh@Q]←PAiQJ↓ES]I%]NA←_AKee1Sgh@↓S\AK→MKGh4∀@@@AChAQQJAi%[JA←_AiQJAmCYIKhBR8@A+g%]NAgUgaK]⊂XAiQ∀AgkEMsgiK4@Agi¬eik`↓[KeK1r~∀@@@AG¬kgKf↓BAeKQke\A→e←ZAQQJAgUgaK]⊂AMk]
iS←\8~∀~∀4∀@@@@@@@@@@@@@@@@@@@AS\AQQJA)=!&Zb@AS[a1K[K]QCiS←8~∀~∀@@@@@A)Q∃eJASLAGkeIK]iYd@A]↑↓oCrA→←d@A1∪' AQ↑AeKQke\@↓BAG←5[C]H↓gieS9N@Ai<AiQJ4∀@@@A≠←]%i←d@↓S\@AQQJ@AQ∨!&ZD`AS[AYK[K9iCiS=\\@@↓⊃←oKYKdX@QmCYIKhR@↓oSYX↓eKikI\~∀@@@AG=]ie←0Ai↑AQQJA[=]Si←HAg↑AQQChA∧AG←[5C]HA5CrAE∀A[C]UCYYr↓isaK⊂\@@AQQK\AQsaJ~(@@@@↓π∨≥)%≥+
AQ↑AeKMk[JA1∪' \4∀~∀@@@@@A)QJAeK[¬eWf@↓CE←m∀@ACE=kh@AYCYeKP@AC]⊂@AgkMaK]HAQ←Y⊂@AM←H@AiQ∀A)∨!LZb`~(@@@@↓S[aY∃[K]i¬iS←\↓CYg↑8~∀~∀4∀b\p8h@Aβ⊃ISiS=]CXA→k]Gi%←]f~(~∀~∃MkEd@@@@@@@@@@@@AM+¬$@DACeN4∀~∀@@@@@A)QJ↓CeOk5K]hX↓BAMSa]kZX↓SfAi¬WK\AQ↑AEJ↓iQJA¬IIeKMfA←L↓B@AY=GCiS=\AoSQQS\~(@@@@↓BAG←5aSYK⊂A←dAMsgiK4AMk]
iS←\8@Agk dACiQK[aiLAi↑A⊃KiKe5S]JAQQJA]¬[J@A=LAiQ∀~∀@@@AMk9GiS←8@AErAOe←YKYS]≤AiQe=kOP@↓iQJ@↓Gkee∃]hA← CeeCd@AY←=WS]NACh@↓CYXAQQJ~∀@@@A
←[aS1KHAMU]GiS=\Aae=aKei%Kf\@↓∪LASPAMCS1fASh↓eKikI]f@D|D\@AQQSfA%fAkg∃HAEr4∀@@@AECWQeCGJ0AM←d↓KqC[AYJ\@A)QSLAMk]
iS←\↓[CrA J@AkMKMkX↓i↑AkMKd@A!C]IY∃efAM=d~∀@@@Ai!JA[C
QS]J5Kee←HAS]i∃eekaPXAM←HAKqC5aYJ\4∀@@@@@@@A)QJ↓M←YY=oS]N↓Mk]GQS←\A∃qSgiLA←]YdAS\AQQJA∪Q&AS[AYK[K9iCiS=\~∀~)gsgG¬YX@@@@@@@@@@↓→'+¬H@dAi<@b`A¬eOf~(~∀@@@@@@↓)QSf↓Mk]GQS←\A¬YY←oLAiQJ↓→∪' ↓kgKd↓i↑AI%eKGi1rASgMkJA∪Q&Ags5E←YS AgsgQKZ~∀@@@A
CYYf8@A)Q∀AMSeMhACe≥k[K]PAgQ←UYHAE∀~∀@@@@@@@@@@@@@@@@@@@@@@@@@P,@QYg AF@b`\RA\$~∀~∀@@@@@AoQ∃eJA\↓SfAi!JAIKMSeKH↓]k[E∃dA←L↓←kiaUhAmC1kKfA¬]HAF↓SfAi!JAG←9ie←X↓ESif4∀~∀~) KGK5EKd@XX@br\n@@@@@@@@@@@@@@@@&fZD\p\f@@@@@@@@@@@@@@@@@@@@↓!COJfZb`L~∀_TU Iβ
(T(@@@@@@@@@@@@@@@A5CGYSM`A%K→KeK]
JA≠C9kCX@@@@@@@@@@@@@@@TU⊃%β
((T~∀~(~∀@@@AM←HAiQJ↓GCYX8@A)Q∀AgKG=]H@A¬eOk[∃]hAg!←kYH↓EJAC8ACi←5SFAge[E←XAoQ←MJAa]¬[J~∀@@@A%fAiQ∀A]C[∀A←L@↓iQJA%)&AgegiKZ↓GCYX8@A)Q∀@AeKMhA←L↓iQJA¬eOk[∃]if@↓gQ←k1HAEJ4∀@@@AiQJ↓S]akPACeOU[K]iLAM←d↓iQJA
CYX\@Aβ\↓CeOk5K]hA5CrAE∀ABAM%q]kZ0A←d@↓BAMS1J~∀@@@A← UKGh@QM←H@AoQ%GP@AQQJ@A→SYJOLAGQC9]KX@↓]k[E∃d@ASL@Akg∃HR\@A∪L@↓iQJA
CYX~(@@@@↓gkGG∃KIfX↓BAYSMh@A←_A\AM%q]k[L@ASf↓eKikI]KH\A∪L@↓C\AKIe←dA=GGkeLX@Ai!JA∪)L~∀@@@AKeI←dAG=IJASLAeKiUe]KH↓CfAB↓MSq]UZ\~∀4∀@@@@@@A∃qC[a1Jt@@Qgsg
CYX@@@OgG5XAis$@fR~(@@@@@@@@@@Ag∃ifAi!JA]k5EKdA=LAKG!↑AYS9Kf@A→←dAi!JAiidAi↑@LAC]H↓eKikI]f@A9SXA←8~∀@@@@@@@@@@↓gkGG∃gf\~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∀~(~∀~∀4∀~∃!¬OJ@f4b`h@@@@@@@@@@@@@@@@@@@@@LfZb\`\h@@@@@@@@@@@@@@@A K
K[EKH@lX@Drnn~(_TU Iβ
(T(@@@@@@@@@@@@@@@@@@@@↓
k]GQS←\A%]IKp@@@@@@@@@@@@@@@@@@TU⊃%β
((T~∀~)]C[J$∪aCO∀∪isa∀~∀T∩$b`d∪1'+¬$`A←d↓[←eJ↓CeOf4∀TH∩$b`j∪1'+¬$`A←d↓[←eJ↓CeOf4∀UCeICr∩∩Ddd∪→M+¬$@LA←dA5←eJA¬eOf~(UISL$∩b``%'+¬$dACe≥f~∀U→k]Gi%←\∩f\∪
'+ $~∀UEk↑∩∩D`b∪'U¬$@d↓CeOf4∀UeK¬eeCr$bdf∪1'+¬$bA←d↓[←eJ↓CeOf4∀Ueg∃h∩∩bX`∪'+ $@bA¬eN~∀)egKh$∩bl`%'/∪)
⊂~∀V$∩b`d%→'+¬H@`A←HA[←e∀ACeOL~∀VH$∩b`j%→'+¬H@`A←HA[←e∀ACeOL~∀Z∩$b`d∪1'+¬$`A←d↓[←eJ↓CeOf4∀ZH∩$b`j∪1'+¬$`A←d↓[←eJ↓CeOf4∀↑∩∩D`f∪→M+¬$@@A←dA5←eJA¬eOf~(↑H∩∩D`l∪→M+¬$@@A←dA5←eJA¬eOf~(bV∩∩D`f∪'U¬$@b↓CeN~(bVH∩$b`l∪M+¬$@DACeN4∀bZ∩$b`f∪M+¬$@DACeN4∀bZH$∩b`l%'+¬$bACe≤~∀x∩$rl∪'U¬$@d↓CeOf4∀z∩∩dj∪'+ $@dA¬eOf~(|∩∩rT∪'+¬H@dACIOf~∃p∩∩b`L∪'+¬H@dACIOf~∃q8∩∩b@f∪'+ $@dA¬eOf~)<∩∩b@h∪'+ $@dA¬eOf~)<H∩∩D`l∪'U¬$@d↓CeOf4∃=H∩$brd∪M/∪)π ~∃=N$∩bhh%'+¬$`ACe≥f~∃C f∩∩r\∪'+¬H@bACIN~∃C⊃Hb∩∩D``∪'U¬$@b↓CeN~)CYCe5GY←G,∩bhr%'+¬$dACe≥f~∃C1Y←F∩$brj∪M+¬$@DACeN4∃CYa!CYKgM`∩ph%'+¬$dACe≥f~∃C9H∩∩lP∪
'+ $~∃CAaK]H$∩hn∪1'+¬$`A←d↓[←eJ↓CeOf4∃Caa40 SUBR 1 arg
args 91 LSUBR 1 or 2 args
array 122 FSUBR
arraycall 42 FSUBR
arraydims 123 SUBR 1 arg
ascii 113 SUBR 1 arg
assoc 56 SUBR 2 args
assq 57 SUBR 2 args
atan 108 SUBR 2 args
atom 29 SUBR 1 arg
baklist 161 LSUBR 0 to 1 arg
baktrace 161 LSUBR 0 to 2 args
baktrace1 165 LSUBR 0 to 2 args
baktrace2 165 LSUBR 0 to 2 args
bigp 29 SUBR 1 arg
boole 110 LSUBR 3 or more args
boundp 79 SUBR 1 arg
break 136 FSUBR
c...r 44 SUBR 1 arg
car 43 SUBR 1 arg
car 43 SWITCH
catch 72 FSUBR
catenate 117 LSUBR 0 or more args
cdr 43 SUBR 1 arg
cdr 43 SWITCH
cline 233 SUBR 1 arg
comment 38 FSUBR
cond 64 FSUBR
cons 44 SUBR 2 args
copysymbol 87 SUBR 2 args
cos 108 SUBR 1 arg
cxr 62 SUBR 2 args
defprop 83 FSUBR
defun 89 FSUBR
delete 54 LSUBR 2 or 3 args
delq 55 LSUBR 2 or 3 args
difference 99 LSUBR 1 or more args
do 67 FSUBR
dumparrays 125 SUBR 2 args
eq 31 SUBR 2 args
equal 31 SUBR 2 args
err 75 FSUBR
errframe 161 SUBR 1 arg
error 74 LSUBR 0 to 3 args
errprint 162 LSUBR 1 to 2 args
errset 74 FSUBR
eval 35 LSUBR 1 or 2 args
evalframe 162 SUBR 1 arg
evalhook 163 LSUBR 2 or 3 args
exp 107 SUBR 1 arg
explode 115 SUBR 1 arg
explodec 115 SUBR 1 arg
exploden 115 SUBR 1 arg
expt 100 SUBR 2 args
fillarray 124 SUBR 2 args
fix 97 SUBR 1 arg
fixp 29 SUBR 1 arg
flatc 116 SUBR 1 arg
flatsize 115 SUBR 1 arg
float 97 SUBR 1 arg
floatp 29 SUBR 1 arg
freturn 163 SUBR 2 args
fsc 112 SUBR 2 args
funcall 41 LSUBR 1 or more args
function 36 FSUBR
gc 191 FSUBR
gcd 100 SUBR 2 args
gctwa 191 FSUBR
gensym 87 LSUBR 0 or 1 args
get 81 SUBR 2 args
get←pname 118 SUBR 1 arg
getchar 113 SUBR 2 args
getcharn 114 SUBR 2 args
getl 81 SUBR 2 args
getsp 206 LSUBR 1 to 2 args
go 70 FSUBR
greaterp 95 LSUBR 2 or more args
haipart 98 SUBR 2 args
haulong 94 SUBR 1 arg
hunk 61 LSUBR 0 or more args
hunkp 30 SUBR 1 arg
hunksize 62 SUBR 1 arg
ifix 97 SUBR 1 arg
implode 114 SUBR 1 arg
index 117 SUBR 2 args
intern 87 SUBR 1 arg
ioc 144 FSUBR
iog 145 FSUBR
last 46 SUBR 1 arg
length 46 SUBR 1 arg
lessp 95 LSUBR 2 or more args
list 47 LSUBR 0 or more args
listarray 124 LSUBR 1 or 2 args
listify 41 SUBR 1 arg
loadarrays 125 SUBR 1 arg
log 107 SUBR 1 arg
lsh 111 SUBR 2 args
lsubrcall 42 FSUBR
make←atom 118 SUBR 1 arg
makhunk 62 SUBR 1 arg
maknam 114 SUBR 1 arg
maknum 58 SUBR 1 arg
makunbound 79 SUBR 1 arg
mapatoms 129 LSUBR 1 or 2 args
max 96 LSUBR 1 or more args
member 53 SUBR 2 args
memq 54 SUBR 2 args
min 96 LSUBR 1 or more args
minus 98 SUBR 1 arg
minusp 93 SUBR 1 arg
munkam 58 SUBR 1 arg
nconc 48 LSUBR 0 or more args
ncons 45 SUBR 1 arg
nointerrupt 150 SUBR 1 arg
not 32 SUBR 1 arg
nouuo 160 SUBR 1 arg
nouuo 160 SWITCH
nreconc 49 SUBR 2 args
nreverse 49 SUBR 1 arg
null 32 SUBR 1 arg
numberp 30 SUBR 1 arg
oddp 93 SUBR 1 arg
or 64 FSUBR
pagebporg 206 SUBR no args
plist 83 SUBR 1 arg
plus 99 LSUBR 0 or more args
plusp 93 SUBR 1 arg
pnget 85 SUBR 2 args
pnput 85 SUBR 2 args
prog 66 FSUBR
prog2 38 LSUBR 2 or more args
progn 39 LSUBR 1 or more args
progv 39 FSUBR
purcopy 205 SUBR 1 arg
purify 206 SUBR 3 args
putprop 82 SUBR 3 args
quit 233 SUBR no args
quote 35 FSUBR
quotient 99 LSUBR 1 or more args
random 109 LSUBR 0 to 2 args
readlist 114 SUBR 1 arg
remainder 100 SUBR 2 args
remob 87 SUBR 1 arg
remprop 83 SUBR 2 args
return 71 SUBR 1 arg
reverse 48 SUBR 1 arg
rot 111 SUBR 2 args
rplaca 51 SUBR 2 args
rplacd 51 SUBR 2 args
rplacx 62 SUBR 3 args
runtime 232 SUBR no args
samepnamep 84 SUBR 2 args
sassoc 57 SUBR 3 args
sassq 58 SUBR 3 args
save 202 FSUBR
sat 78 SUBR 2 args
setarg 40 SUBR 2 Args
satplist 83 SUBR 2 args
satq 77 FSUBR
signp 94 FSUBR
cin 108 SUBR 1 Arg
sleep 232 SUBR 1 arg
soRt 59 SUBR 2 args
sortcar 60 SUBR 2 args
sqrt 107 SUBR 1 arg
sstatus 210 FSUBR
status 210 FSUBR
store 123 FSUBR
stringlength 117 SUBR 1 arg
stringp 30 SUBR 1 arg
sub1 100 SUBR 1 arg
sublis 52 SUBR 2 args
subr 234 SUBR 1 arg
subrcall 41 FSUBR
subrp 30 SUBR 1 arg
subst 52 SUBR 3 args
substr 118 LSUBR 2 or 3 args
suspend 202 LSUBR 0 to 2 args
sxhash 55 SUBR 1 arg
symbolp 29 SUBR 1 arg
symeval 78 SUBR 1 arg
syscall 234 LSUBR 2 to 10 args
sysp 91 SUBR 1 arg
throw 73 FSUBR
time 232 SUBR no args
times 99 LSUBR 0 or more args
typep 30 SUBR 1 arg
valret 233 LSUBR 0 or 1 args
xcons 45 SUBR 2 args
zerop 93 SUBR 1 arg
zunderflow 109 SWITCH